01 2013 档案
摘要：File类：1、用来将文件或者文件夹封装成对象2、方便对文件与文件夹的属性信息进行操作3、File对象可以作为参数传递给流的构造函数4、了解 File类的常用方法File类的常见方法：1、创建： boolean createNewFile()，在指定位置创建文件，如果该文件已经存在，则不会创建，返回false. 和输出流不一样，输出流对象一建立创建文件，如果文件已经存在，则会被覆盖. boolean mkdir(); 创建目录 boolean mkdirs();创建多级目录2、删除： boolean delete(); 删除失败返回 false. void deleteOnExit(); ..
阅读全文
摘要：importjava.io.*;classFileTree{/*以树形结构列举出指定目录下的文件与文件夹*/publicstaticvoidmain(String[]args)throwsIOException{BufferedReaderbr=newBufferedReader(newInputStreamReader(System.in));System.out.println("请键入您要查看的路径：");Stringpath=br.readLine();if(null!=path){printFiles(newFile(path).listFiles(),0);}}
阅读全文
摘要：importjava.io.*;importjava.util.*;classPrintPropertiesToStreamDemo{publicstaticvoidmain(String[]args)throwsIOException{Propertiesps=System.getProperties();//打印到标准输出设置ps.list(System.out);//通过流打印到文件ps.list(newPrintStream(newFile("sysinfo.txt")));}}
阅读全文
摘要：importjava.io.*;importjava.text.*;importjava.util.*;classExceptionInfo{publicstaticvoidmain(String[]args){try{int[]array=newint[2];System.out.println(array[3]);}catch(Exceptione){try{System.setOut(newPrintStream(newFile("err.txt")));Stringdate=newSimpleDateFormat("yyyy-MM-ddHH:mm:ss:S
阅读全文
摘要：importjava.io.*;classSystemInDemo{/*以键盘录入与屏幕输出为例*/publicstaticvoidmain(String[]args)throwsIOException{//改变标准输入与输出设备实例文件复制操作System.setIn(newFileInputStream(newFile("BufferedCopyFileDemo.java")));System.setOut(newPrintStream(newFile("hah.txt")));//字节流->字符流//字符流->字节流BufferedRe
阅读全文
摘要：importjava.io.*;/*自定义缓冲区*/classMyBufferedInputStreamDemo{publicstaticvoidmain(String[]args)throwsIOException{MyBufferedInputStreammis=newMyBufferedInputStream(newFileInputStream(newFile("001.avi")));BufferedOutputStreambos=newBufferedOutputStream(newFileOutputStream(newFile("001-1.avi
阅读全文
摘要：importjava.io.*;classBufferedCopyFileDemo{publicstaticvoidmain(String[]args)throwsIOException{BufferedInputStreambis=null;BufferedOutputStreambos=null;try{bis=newBufferedInputStream(newFileInputStream(newFile("001.avi")));bos=newBufferedOutputStream(newFileOutputStream(newFile("001-1.
阅读全文
摘要：importjava.io.*;classImageCopyDemo{publicstaticvoidmain(String[]args){FileInputStreamfis=null;FileOutputStreamfos=null;try{fis=newFileInputStream(newFile("001.png"));fos=newFileOutputStream(newFile("001-copy.png"));/*byte[]buffer=newbyte[fis.available()];fis.read(buffer);fos.writ
阅读全文
摘要：importjava.io.*;importjava.text.*;importjava.util.*;classFileOutputStreamDemo{publicstaticvoidmain(String[]args)throwsIOException{writeFile(newSimpleDateFormat("yyyy-MM-ddHH:mm:ss:SE").format(newDate()));readFile_1();}//小文件便捷读取方式，大文件禁用publicstaticvoidreadFile_3()throwsIOException{FileInput
阅读全文
摘要：importjava.io.*;classMyReaderLineNumberDemo{publicstaticvoidmain(String[]args){MyReaderForLineNumbermrln=null;try{mrln=newMyReaderForLineNumber("MyReaderLineNumberDemo.java");Stringline=null;mrln.setStartLineNumber(1);mrln.setEndLineNumber(-1);while((line=mrln.readLine())!=null){System.out
阅读全文
摘要：importjava.io.*;classMyReaderLineNumberDemo{publicstaticvoidmain(String[]args)throwsIOException{MyReaderLineNumbermrln=newMyReaderLineNumber("MyReaderLineNumberDemo.java");Stringline=null;mrln.setReaderLineNumber(100);while((line=mrln.readerLine())!=null){System.out.println(mrln.getReaderL
阅读全文
摘要：装饰设计模式：当想要对已有的对象进行功能增强时，可以定义类，将已有对象传入，基于已有的功能，并提供加强功能！那么，自定义的该类称为装饰类。装饰类通常会通过构造方法接收被装饰的对象。并基于被装饰的对象的功能，提供更强的功能。装饰模式比继承要灵活，避免了继承体系的臃肿，而且降低了类与类之间的关系。装饰类因为增强已有对象，具备的功能和已有的相同的，只不过提供了更强的功能。所以装饰类和被装饰类通常都是属于同一个体系中。MyReader // 专门用于读取数据的类 |--- MyTextReader //文本读取 |--- MyMediaReader //媒体读取 |--- MyDataReader .
阅读全文
摘要：importjava.io.*;classMyBufferedReaderDemo{publicstaticvoidmain(String[]args)throwsIOException{MyBufferedReadermyReader=newMyBufferedReader("MyBufferedReaderDemo.java");Stringline=null;while((line=myReader.readLine())!=null){System.out.println(line);}myReader.close();}}classMyBufferedReader
阅读全文
摘要：importjava.io.*;classBufferedCopyDemo{/*通过缓冲区复制一个.java文件*/publicstaticvoidmain(String[]args){FileWriterfileWriter=null;FileReaderfileReader=null;BufferedWriterbufferedWriter=null;BufferedReaderbufferedReader=null;try{fileWriter=newFileWriter("d:\\BufferCopyDemo.java");fileReader=newFileRea
阅读全文
摘要：字符流的缓冲区：1、缓冲区的出现提高了对数据的读写效率。2、对应类： a)BufferedWriter b)BufferedReader3、缓冲区要结合流才可以使用。4、在流的基础上对流的功能进行了增强。一、字符流的写缓冲区：importjava.io.*;importjava.util.*;importjava.text.*;classBufferedWriterDemo{/*缓冲区的出现是为了提高流的操作效率而出现的。所以在创建缓冲区之前，必须要先有流对象。*/publicstaticvoidmain(String[]args)throwsIOException,InterruptedE.
阅读全文
摘要：importjava.io.*;classFileCopyDemo{/**文件的复制*/publicstaticvoidmain(String[]args){FileWriterfw=null;FileReaderfr=null;try{fr=newFileReader("d:\\works\\demo.txt");fw=newFileWriter("d:\\demo.txt");char[]buffer=newchar[1024];intlength=0;while((length=fr.read(buffer))!=-1){fw.write(buff
阅读全文
摘要：importjava.io.*;classFileReaderDemo{publicstaticvoidmain(String[]args){FileReaderfr=null;try{fr=newFileReader("demo.txt");/*//定义一个缓冲区char[]buffer=newchar[3];intlength1=fr.read(buffer);sop("length1:"+length1+":"+newString(buffer,0,length1));intlength2=fr.read(buffer);sop
阅读全文
摘要：importjava.io.*;classFileReaderDemo{publicstaticvoidmain(String[]args){/*创建一个文件读取流，和指定名称的文件相关联。要保证该文件是已经存在的，如果不存在，会发生异常：FileNotFoundException创建对象引用：*/FileReaderfr=null;try{//实例化对象fr=newFileReader("demo.txt");/*读取单个字符：intc1=fr.read();sop((char)c1);intc2=fr.read();sop((char)c2);intc3=fr.read
阅读全文
摘要：importjava.io.*;importjava.text.*;importjava.util.*;classFileWriterDemo{publicstaticvoidmain(String[]args){FileWriterfw=null;try{//续写:根据给定的文件名以及指示是否附加写入数据的boolean值来构造FileWriter对象。fw=newFileWriter("demo.txt",true);for(inti=0;i<10;i++){fw.write(newSimpleDateFormat("yyyy-MM-ddHH:mm:ss
阅读全文
摘要：IO(Input Output)流：1、IO流用来处理设备之间的数据传输2、Java对数据的操作是通过流的方式3、Java用于操作流的对象都在IO包中4、流按操作数据分为两种：字节流与字符流5、流按流向分为：输入流与输出流字节流的抽象基类：1、InputStream2、OutputStream字符流的抽象基类：1、Reader2、Writer由这四个类派生出来的子类名称都是以其父类名做为子类名的后缀，如：InputStream 的子类：FileInputStreamReader 的子类：FileReader示例：importjava.io.*;classFileWriterDemo{publ.
阅读全文
摘要：classMathDemo{publicstaticvoidmain(String[]args){//abs获取指定数据的绝对值sop(Math.abs(-12));//ceil返回大于指定数据的最小整数。sop(Math.ceil(-16.34));//floor返回小于指定数据的最大整数sop(Math.floor(12.34));//四舍五入sop(Math.round(12.34));//计算2的3次幂sop(Math.pow(2,3));for(inti=0;i<10;i++){//返回一个伪随机数//sop((int)(Math.random()*10+1));sop(new
阅读全文
摘要：/***每周三、六休息，从2013年01月01日起至今天，总计休息多少天？*/publicstaticvoidgetRest(){Calendarc=Calendar.getInstance();c.set(2012,0,1);Calendard=Calendar.getInstance();intresult=0;while(c.compareTo(d)<=0){if(c.get(Calendar.DAY_OF_WEEK)==3||c.get(Calendar.DAY_OF_WEEK)==6)result++;c.add(Calendar.DAY_OF_MONTH,1);}sop(re
阅读全文
摘要：importjava.util.*;importjava.text.*;classCalendarDemo{publicstaticvoidmain(String[]args){Dated=newDate();//获取年（旧方法）//sop(newSimpleDateFormat("yyyy").format(d));//获取年（新方法），以查表法取月和星期String[]months={"一月","二月","三月","四月","五月","六月",&quo
阅读全文
摘要：importjava.util.*;importjava.text.*;classDateDemo{publicstaticvoidmain(String[]args){Dated=newDate();sop(d);/*日期格式化：将模式封装到SimpleDateFormat对象中。字母日期或时间元素表示示例--------------------------------------------------GEra标志符TextADy年Year1996;96M年中的月份MonthJuly;Jul;07w年中的周数Number27W月份中的周数Number2D年中的天数Number189d月份.
阅读全文
摘要：Runtime对象该类并没有提供构造函数，说明不可以new 对象，那么会直接想到该类中的方法都是静态的。发现该类中还有非静态方法，说明该类肯定提供了方法获取本类对象，而且该方法是静态的，并返回值类型是本类类型。由这个特点可以看出该类使用了单例设计模式。该方法是 static Runtime getRuntime();执行命令：runtime.exce("应用程序 参数");示例：importjava.io.*;classRuntimeDemo{publicstaticvoidmain(String[]args)throwsIOException,InterruptedExc
阅读全文
摘要：System：类中的方法和属性都是静态的。out：标准输出，默认是控制台。in ：标准输入，默认是键盘。 描述系统一些信息：Properties p = new System.getProperties();/*Properties 是 Hashtable的子类，也就是Map集合的一个子类对象。那么可以通过map的方法取出该集合中的元素。*/示例：importjava.util.*;classSystemDemo{publicstaticvoidmain(String[]args){/*获取和打印系统信息*/Propertiesp=System.getProperties();for(Map.
阅读全文
摘要：集合转换为数组：1、指定类型的数组到底要定义多长呢？当指定类型的数组长度小于了集合的size，那么该方法内部会创建一个新的数组。长度为集合的size。当指定类型的数组长度大于了集合的size，就不会新创建数组了，而是使用传递进来的数组。所以创建一个刚刚好的数组最优。ArrayList<String>al=newArrayList<String>();al.add("abc");al.add("cba");al.add("bac");al.add("cab");al.add("bca
阅读全文
摘要：数组转换为集合：将数组转换为集合的处好：可以用集合的思想和方法操作数组。将数组转换为集合以后，不能使用集合的增、删操作：原因：数组的长度不可改变！异常：UnsupportedOperationException如果数组中的元素都是对象，那么转换为集合时，数组中的元素就直接转成集合中的元素，如下：String[]strArr={"aa","bb","cc"};List<String>strList=Arrays.asList(strArr);Integer[]numArr={1,3,4,5,2,8,9};List<In
阅读全文
摘要：可变参数：其实就是一种数组参数的简写形式，不用每一次都手动建立数组对象。只要将要操作的元素作为参数传递既可。隐式将这些参数封装成了数组。注意：可变参数只能作为最后一个参数存在！格式： MethodName(数据类型... 变量名)示例：publicstaticvoidshow(int...parms){for(inti:parms){System.out.println(i);}}泛型示例：publicstatic<T>voidshow(T...parms){for(Ti:parms){System.out.println(i);}}
阅读全文
摘要：增强的For循环：格式：for(数据类型 变量名 ： 被遍历的集合（Collection）或者数组){}对集合进行遍历：只能获取元素，但是不能对集合进行操作。迭代器，除了遍历，还可以进行remove集合中元素的动作。如果使用 ListIterator 还可以在遍历过程中对集合进行增、删、改、查的动作。传统的for循化与增强的for循环的区别：高级for循环有一个局限性，必须有被遍历的目标。建议在遍历数组时，使用传统 for 循环，因为传统for循环可以定义角标for(int i = 0;i<arr.length;i++){}传统遍历与高级遍历的演示：importjava.util.*;c
阅读全文
摘要：静态导入：当类重名时，需要指定具体的包名。当方法重名时，指定具备所属的对象或者类。格式：import static 类名;示例：importjava.util.*;importstaticjava.util.Arrays.*;importstaticjava.lang.System.*;classStaticImportDemo{publicstaticvoidmain(String[]args){int[]nums={1,3,4,2,5};sort(nums);intindex=binarySearch(nums,5);sop(Arrays.toString(nums));sop(inde.
阅读全文
摘要：Map集合--------------------------------------------------------------------------该集合存储键值对，一对一对往里存；而且要保证键的唯一性。增加：V put(K key,V value); 如果添加相同键的值，那么会覆盖原有值，并返回被覆盖的值void putAll(Map<? extends K,? extends V) m);删除：void clear();remove(Object key);判断：boolean containsValue(Object value);boolean containsKey(
阅读全文
摘要：importjava.util.*;classMapTest{publicstaticvoidmain(String[]args){Stringtmp=newString("sdfgzxcvasdfxcavdf");Map<Character,Integer>map=newTreeMap<Character,Integer>(newComparator<Character>(){publicintcompare(Characterc1,Characterc2){returnc1.compareTo(c2);}});for(Characte
阅读全文
摘要：importjava.util.*;classHashMapDemo{publicstaticvoidmain(String[]args){Map<Student,String>studentMap=newHashMap<Student,String>();studentMap.put(newStudent("张三",21),"山东");studentMap.put(newStudent("李四",20),"河南");studentMap.put(newStudent("王五&qu
阅读全文
摘要：importjava.util.*;classGenericDemo{publicstaticvoidmain(String[]args){TreeSet<Person>ts=newTreeSet<Person>(newMyComparator());ts.add(newPerson("张三","男",28,175));ts.add(newPerson("李四","女",28,160));ts.add(newPerson("王五","女",27,185
阅读全文
摘要：泛型：在JDK1.5版本以后出现的新特性，用于解决安全问题，是一个安全机制（高效、简化书写、安全）。好处：1，将运行时异常：（ClassCastException），转移到了编译时期，方便于程序员解决问题，让运行时期问题减少。2，避免了强制转换的麻烦。格式：通过<>来定义要操作的引用数据类型。在使用Java提供的对象时，什么时候写泛型？通常在集合框架中很常见，只要见到<>就要定义泛型。当类中要操作的引用数据类型不确定时，早期定义Object来完成扩展，现在定义泛型来完成扩展。<>就是用来接收类型的，当使用集合时，将集合中要存储的数据类型作为参数传递到<
阅读全文
摘要：集合类 Collection----------------------------------------------------------------------为什么出现集合类？面向对象语言对事物的体现都是以对象的形式，所以为了方便对多个对象的操作，就对对象进行存储，集合就是存储对象最常用 的一种方式。数组和集合类同是容器，有何不同？数组虽然也可以存储对象，但长度是固定的；集合长度是可变的。数组中可以存储基本数据类开，集合只能存储对象。集合类的特点集合只用于存储对象，集合长度是可变的，集合可以存储不同类型的对象。集合框架--------------------------------.
阅读全文
摘要：importjava.util.*;classGenericDemo{publicstaticvoidmain(String[]args){TreeSet<Person>ts=newTreeSet<Person>(newMyComparator());ts.add(newPerson("张三","男",28,175));ts.add(newPerson("李四","女",28,160));ts.add(newPerson("王五","女",27,185
阅读全文
摘要：StringBuilder--------------------------------------------------------------在JDK1.5版本之后出现了StringBuilder与StringBuffer是线程同步，StringBuilder是线程不同步。单线程建议使用StringBuilder，多线程建议使用StringBuffer.==============================================================升级的三个因素：1，提高效率2，简化书写3，提高安全性开发中建议使用StringBuilder，若遇到多线程时.
阅读全文
摘要：StringBuffer-----------------------------------------------------------------------------------StringBuffer 是字符串缓冲区，是一个容器特点：1，长度是可以变化的2，可以直接操作多个数据类型3，最终会通过toString()变成字符串CURDCreate Update Read Delete==================================================================================1，存储 StringBuffer .
阅读全文
摘要：String-----------------------------------------------------------------------------------------一、String类适用于描述字符串事物。 那么它就提供了多个方法对字符串进行操作。常见的操作有哪些？"abcd"1，获取 1.1 字符串中的包含的字符数，也就是字符串的长度。 int length() ： 获取长度。 1.2 根据位置获取位置上某个字符。 char charAt(int index)： 1.3 根据字符获取该字符在字符串中位置 int indexOf(int ch) ：返
阅读全文
摘要：classJoinThreadDemo{publicstaticvoidmain(String[]args){JoinThreadjoinThread=newJoinThread();Threadt1=newThread(joinThread,"t1");Threadt2=newThread(joinThread,"t2");t1.start();try{t1.join();}catch(Exceptione){System.out.println(Thread.currentThread().getName()+"Exception"
阅读全文
摘要：classThreadDemo{publicstaticvoidmain(String[]args){newThread(){publicvoidrun(){for(inti=0;i<100;i++){System.out.println(Thread.currentThread().getName()+"...."+i);}}}.start();for(inti=0;i<100;i++){System.out.println(Thread.currentThread().getName()+"...."+i);}Runnabler=newR
阅读全文
摘要：classDaemonThreadDemo{publicstaticvoidmain(String[]args){StopThreadstopThread=newStopThread();Threadt1=newThread(stopThread,"t1");Threadt2=newThread(stopThread,"t2");t1.setDaemon(true);t2.setDaemon(true);t1.start();t2.start();intnum=0;while(true){if(num++==60){stopThread.changeFl
阅读全文
摘要：classStopThreadDemo{publicstaticvoidmain(String[]args){StopThreadstopThread=newStopThread();Threadt1=newThread(stopThread,"t1");Threadt2=newThread(stopThread,"t2");t1.start();t2.start();intnum=0;while(true){if(num++==60){//this.changeFlag();t1.interrupt();t2.interrupt();break;}Sy
阅读全文
摘要：classProducerConsumerDemo{publicstaticvoidmain(String[]args){Productproduct=newProduct();newThread(newProducer(product)).start();newThread(newConsumer(product)).start();newThread(newProducer(product)).start();newThread(newConsumer(product)).start();newThread(newProducer(product)).start();newThread(n
阅读全文
摘要：classProducerConsumerDemo{publicstaticvoidmain(String[]args){Productproduct=newProduct();newThread(newProducer(product)).start();newThread(newConsumer(product)).start();}}classProduct{privateintcount;privatebooleanflag;publicsynchronizedvoidcreate(){while(this.flag){try{this.wait();}catch(Exceptio..
阅读全文
摘要：classThreadCommunicationDemo{publicstaticvoidmain(String[]args){Resourceresource=newResource();Inputinput=newInput(resource);Outputoutput=newOutput(resource);newThread(input,"inputthread").start();newThread(output,"outputthread").start();}}classInputimplementsRunnable{privateReso
阅读全文
摘要：classThreadCommunicationDemo{publicstaticvoidmain(String[]args){Resourceresource=newResource();Inputinput=newInput(resource);Outputoutput=newOutput(resource);newThread(input,"inputthread").start();newThread(output,"outputthread").start();}}classInputimplementsRunnable{privateReso
阅读全文
摘要：classSingleDemo{publicstaticvoidmain(String[]args){for(inti=1;i<10;i++){Threadt1=newTest();t1.start();}}}classTestextendsThread{publicvoidrun(){Singlesingle=Single.getInstance();System.out.println(this.getName()+"getInstance:"+single);}}classSingle{privatestaticfinalSingleSINGLE=newSing
阅读全文
摘要：classSingleDemo{publicstaticvoidmain(String[]args){for(inti=1;i<10;i++){Threadt1=newTest();t1.start();}}}classTestextendsThread{publicvoidrun(){Singlesingle=Single.getInstance();System.out.println(this.getName()+"getInstance:"+single);}}classSingle{privatestaticSinglesingle=null;private
阅读全文
摘要：classSaleTicketDemo{publicstaticvoidmain(String[]args){Ticketticket=newTicket();for(inti=1;i<6;i++){newThread(ticket,"window"+i).start();try{Thread.sleep(10);}catch(Exceptionex){System.err.println(ex.getMessage());}}}}classTicketimplementsRunnable{privateintnum=1000;publicvoidrun(){whil
阅读全文
摘要：classBankDemo{publicstaticvoidmain(String[]args){Threadt1=newThread(newPerson());Threadt2=newThread(newPerson());t1.start();t2.start();}}classPersonimplementsRunnable{privatestaticBankbank=newBank();publicvoidrun(){for(inti=0;i<3;i++){bank.add(100);}}}classBank{privateintsum;publicvoidadd(intn){s
阅读全文
摘要：classDeadLockDemo{publicstaticvoidmain(String[]args){Ticketticket=newTicket();for(inti=1;i0){try{Thread.sleep(10);}catch(Exceptione){}System.out.println(Thread.currentThread().getName()+"..sale.."+num--);}}}}
阅读全文
摘要：classDeadLockDemo{publicstaticvoidmain(String[]args){Threadt1=newThread(newTest(true));Threadt2=newThread(newTest(false));t1.start();t2.start();}}classTestimplementsRunnable{privatebooleanflag;publicTest(booleanflag){this.flag=flag;}publicvoidrun(){if(flag){synchronized(Locks.object1){System.out.pr.
阅读全文
摘要：什么是异常？异常是对问题的描述，将问题进行对象的封装。异常体系：Throwable|--Error|--Exception|--RuntimeException异常体系的特点：1，异常体系中的所有类以及建立的对象都具备可抛性。2，也就是说可以被throw和throws关键字所操作。3，只有异常体系具备这个特点。throw 和 throws 的用法：1，throw 定义在函数内，用于抛出异常对象。2，throws 定义在函数上，用于抛出异常类，可以抛出多个，用逗号分隔。当函数内容有throw抛出异常对象，并未进行try处理。必须要在函数上声明，否则编译失败。注意：RuntimeException
阅读全文
摘要：一、异常：就是程序在运行时出现不正常情况。异常由来：问题也是现实生活中一个具体事物，也可以通过java的类的形式进行描述，并封装成对象。 其实就是java对不正常情况进行描述后的对象体现。对于问题的划分：1，严重 java通过Error类进行描述。 对于Error一般不编写针对性的代码对共进行处理。2，非严重 java通过Exception类进行描述。 对于Exception可以使用针对性的处理方式进行处理。共性：无论Error或者Exception都具有一些共性内容，比如：不正常情况的信息，引用原因等。Throwable|--Error|--Exception异常处理：java提供了特有的语
阅读全文
摘要：匿名内部类：1，匿名内部类其实就是内部类的简写格式。2，定义匿名内部类的前提：内部类必须继承一个类或者实现接口。3，匿名内部类的格式：new 父类或者接口(){定义子类内容}4，其实匿名内部类就是一个匿名子类对象，而且这个对象有点儿胖。可以理解为带内容的对象。5，匿名内部类中定义的方法最好不要超过3个。abstract absDemo{ abstract void show();}class Outer{ int x=3; void function() { absDemo a = new absDemo() { voi...
阅读全文
摘要：内部类：1，内部类可以直接访问外部类中的成员，包括私有。 之所以可以直接访问外部类中的成员，是因为内部类中执有了一个外部类的引用，格式：外部类名.this2，外部类要访问内部类，必须建立内部类对象。3，当内部类在成员位置上，就可以被成员修饰符所修饰。 比如：private:将内部类在外部类封装。 static:内部类就具备static的特性。 当内部类被static修饰后，只能直接访问外部类中的static成员，出现了访问局限。 在外部其它类中，如何直接访问静态内部类中的非静态成员？ new Outer.Inner().function(); 在外部其它类中，如何直接访问静态内部类中的...
阅读全文
摘要：可以理解为事物存在的多种体现形态。比如：人 动物 |--男人 |--猫 |--女人 |--狗重载和重写就是方法多态的体现。一、多态的体现 1,父类的引用指向了自己的子类对象。 2,父类的引用也可以接收自己的子类对象。二、多态的前提 1,必须是类与类之间有关系，要么继承，要么实现。 2,通常还有一个前提：存在覆盖。三、多态的好处 1,多态的出现很大的提高程序的扩展性。四、多太的弊端 1,提高了扩展性，但是只能使用父类的引用访问父类中的成员。五、多态的应用六、多态中非静态成员函数的特点 在编译时期：参阅引用型变量所属的类中是否有调用的方法，如果有，编译通过，如果没有，编译失败。 在运行时期：参阅对
阅读全文
摘要：一、主函数（main）1，主函数是一个特殊的函数，作为程序入口，可以被JVM调用。2，定义： a)public：代表着该函数访问权限是最大的。 b)static：代表着主函数随着类的加载就已经存在了。 c)void：主函数没有具体的返回值。 d)main：不是关键字，但是是一个特殊的单词，可以被JVM识别。 e)parameter：函数的参数，参数类型是一个字符串数组(String[] args)。3，主函数是固定格式的：JVM识别。4，JVM在调用主函数时，传入的是new String[0];5，给主函数传参的格式： a)java ClassName 参数1 参数2 参数3 ... b)/*
阅读全文
摘要：Java语言基础组成 -------------------------------------- 关键字 标识符 注释 常量和变量 运算符 语句 函数 数组 -------------------------------------- 标识符-------------------------------------- 在程序中自定义的一些名称由26个英文字母大小写，数字：0-9，符号：_$组成 定义合法标识符规则：1.数字不可以开头。 2.不可以使用关键字。Java中严格区别大小写。 注意：在起名字的时候，为了提高阅读性，要尽量有意义-----------------------------
阅读全文
摘要：面向对象：1，特征： a)封装 b)继承 c)多态2，类和对象的关系 现实生活中的对象：张三，李四。 想要描述：提取对象中共性内容，对具体的抽象。 描述时：这些对象的共性有：姓名，年龄，性别，学习Java功能。3，映射到Java中，描述就是class定的类。 具体对象就是对应Java在堆内存中用new建立起来的实体。4，类就是：对现实生活中事物的描述。 对象：就是这类事物，实实在在存在的个体。5，属性对应类中的变量，行为对应类中的方法（函数）。6，其实定义类，就是描述事物，就是在定义属性和行业，属性和行业共同成为类中的成员（成员变量和成员方法）。
阅读全文
摘要：1，什么是private修饰符？ private是权限修饰符，用于修饰类中的成员（成员变量，成员函数）。 private修饰后的成员只在本类中有效。 /* 例：* 将age私有化以后，类以外即使建立了对象也不能直接访问。 * 但是人应用有年龄，就需要在Person类中提供对应访问age的方式。 * * class Person * { * private int age; * * public void setAge(int age) * { * if(age>0 && age<120) * this.age = age; * else //年龄数据有误，禁止赋值.
阅读全文
摘要：1，封装，是指隐藏对象的属性和实现细节，仅对外提供公共访问方式。2，好外： a)将变化隔离。 b)便于使用。 c)提高重用性。 d)提高安全性。3，封闭原则： a)将不需要对外提供的内容都隐藏起来。 b)把属性都隐藏，提供公共方法对其访问。
阅读全文
摘要：静态代码块：格式：static{ //静态代码块中的执行语句。}特点：随着类的加载而执行，只执行一次，并优先于主函数(main)和构造代码块。class StaticCode{ static { System.out.println("a"); }}
阅读全文
摘要：Person p = new Person("zhangsan",28);该句话都做了什么事情？1，因为new用到了Person.class，所以会先找到Person.class文件并加载到内存中。 2，执行该类中的static代码块，如果有的话，给Person.class类进行初始化。 3，在堆内存中开辟空间，分配内存地址。 4，在堆内存中的建立对象的特有属性，并进行默认初始化。 5，对属性进行显示初始化。 6，对对象进行构造代码块初始化。 7，对对象进行对应的构造函数初始化。 8，将内存地址赋值给栈内存中的变量。
阅读全文
摘要：将编译后的.class文件发送给其他人，其他人通过命令（set classpath=.;c:\[.class文件存放的路径]）就可以使用该类。 但是他不知道该类中有什么方法，多少个方法等信息，此时需要生成java文档一个类中默认会有一个空参数的构造函数，这个默认的构造函数的权限和所属类一致。 如果类被public修饰，那么默认的构造函数也带public修饰符。 如果类没有被public修饰，那么默认的构造函数也没有被public修饰。默认构造函数的权限是随着类的变化而变化的。命令：javadoc -d 存储路径 -author -version 路径
阅读全文
摘要：一、构造函数对象一建立就会调用与之对应的构造函数。1，构造函数的作用： 可以用于给对象进行初始化。 /* 细节： 当一个类中没有定义构造函数时，那么系统会默认结该类加一个空参数的构造函数。 当类中定义了构造函数时，那么系统默认的构造函数就不存在了。 */ 2，构造函数与一般函数的区别： a)写法不同。 b)运行不同。 构造函数是在对象一建立就立即运行，给对象初始化。 而一般方法是对象调用才执行，是给对象添加对象具备的功能。 c)一个对象建立，构造函数只运行一次。 d)一般方法可以被该对象调用多次。3，什么时候定义构造函数？ 在分析事物时，如果该事物存在具备一些特性或者...
阅读全文
摘要：介绍： 在定义功能时，功能的一部分是确定的，但是有一部分是不确定的，而确定的部分在使用不确定的部分，那么这时就将不确定的部分暴露出去。由该类的子类去完成。需求：获取一段程序运行的时间。 原理：获取程序开始和结束的时间并相减即可。获取时间：System.currentTimeMillis();abstract class Runtime{ public final void getTime() { long s = System.currentTimeMillis(); RunMethod(); long e = System.current...
阅读全文
摘要：一、继承缺点： 打破了封装性，此时为了保证封装性使用 final关键字禁止从此类继承。1，提高了代码的复用性。 2，让类与类之间产生了关系，有了这个关系，才有了多态的特性。注意：千万不要为了获取其他类的功能，简化代码而继承。 必须是类与类之间有所属关系才可以继承，所属系 is a.class Person{ String name; int age;}class Student extends Person{ void Speak() { System.out.println("学生-->姓名："+name+"，年龄："+age); }}clas.
阅读全文
摘要：修饰符：final(最终)关键字：1，可以修饰类，函数，变量。 2，被final修饰的类不可以被继承， 为了避免被继承，被子类复写功能。 3，被final修饰的方法不可以被重写（覆盖）。 4，被final修饰的变量是一个常量，只能赋值一次，既可以修饰成员变量，也可以修饰局部变量。 5，内部类定义在类中的局部位置上时，只能访问该局部被final修饰的局部变量。适合场所： 当在描述事物时，一些数据的出现值是固定的，那么这时为了增强阅读性，都给这些值起个名字，方便于阅读。 而这个值不需要改变，所以加上final修饰。 作为常量：常量的书写规范所有的字母都大写，如果由多个单词组成，单词间通过下划线（_
阅读全文
摘要：(abstract)抽象：当多个类中出现相同功能，但是功能主体不同。 这时也可以进行向上抽取，这时，抽取功能定义，而不抽取功能主体。抽象方法必须定义在抽象类中。特点： 1，抽象方法一定定义在抽象类中。 2，抽象方法和抽象类都被必须被 abstract关键字修饰。 3，抽象类不可以被实例化（被 new 创建对象），因为调用抽象方法没有意义。 4，抽象类中的方法要被使用，必须由子类复写其拟有的抽象方法后，建立子类调用。 如果子类只重写了部分抽象方法，那么该子类还是一个抽象类。/********************华丽的分隔线***************************/假如我们在开.
阅读全文
摘要：一、Interface(接口)：初期理解：可以认为是一个特殊的抽象类。 不抽象类中的方法都是抽象的，那么该类可以通过接口的形式来表示。接口： 是不可以被实例化（new 创建对象）的，因为有抽象方法。 需要被子类实现，子类对接口中的抽象方法全部覆盖后，子类才可以实例化。 否则子类是一个抽象类。class 用于定义类，interface 用于定义接口。接口定义时，格式特点： 1，接口中常见定义：常量，抽象方法。 2，接口中的成员都有固定修饰符。 a)常量：public static final b)方法：public abstract 3，接口中的成员都是public的。接口的特点： ...
阅读全文
摘要：一、静态(Static)概念：当成员被静态修饰后，就多了一个调用方式，除了可以被对象调用外，还可以直接被类名调用：类名.静态成员static 特点：1，随着类的加载而加载。 也就是说：静态会随着类的消失而消失。说明它的生命周期最长。2，优先于对象存在。 明确一点：静态是先存在，对象是后存在。3，被所有对象所共享。4，可以直接被类名所调用。二、实例变量和类变量的区别：1，存放位置 a)类变量随着类的加载而存在于方法区中。 b)实例变量随着对象的建立而存在于堆内存中。2，生命周期 a)类变量生命周期最长，随着类的消失而消失。 b)实例变量生命周期随着对象的消失而消失。三、静态的...
阅读全文
摘要：一、this关键字：1，this看上去是用于区分局部变量和成员变量同名情况。 a)this为什么可以解决这个问题？ b)this到底代表的是什么呢？2，this就代表本类的对象，到底代表哪一个呢？ a)this代表它所在函数所属对象的引用。 b)简单说：哪个对象在调用this所在的函数，this就代表哪个对象。3，this的应用： a)当定义类中功能时，该函数内部要用到调用该函数的对象时，这时用this来表示这个对象。 b)但凡本类功能内部使用了本类对象，都用this表示。二、this() 语句：this语句用于构造函数之间进行互相调用。 this语句只能定义在构造函数...
阅读全文
摘要：1，匿名对象是对象的简化形式2，匿名对象两种使用情况： a)当对对象方法仅进行一次调用时 b)匿名对象可以作为实际参数进行传递3，如果对一个对象进行多个成员调用时，必须给这个对象起个名字。
阅读全文
摘要：循环结构：while,do while,forwhile(条件表达式){ }do { }while(条件表达式)do while 与 while结构的区别是，无论条件是否满足，循环体至少被执行一次。1.变量有自己的作用域，对于for来讲：如果将用于控制循环的增量定义在for语句中，那么该变量只在for语句内有效。 for语句执行完毕，该变量在内存中被释放。2.for和while可以互换，如果需要定义循环增量，用for更为合适。总结：什么时候使用循环结构？ 当要对某些语句执行很多次时，就使用循环结构 。如果变量值的结果需要在循环结构以外使用，并且有一定的规律，使用while;无限循环的最简单..
阅读全文
摘要：1，作用范围： a)成员变量作用于整个类中 b)局部变量作用于函数中或者语句中如：for2，在内存中的位置： a)成员变量在堆内存中，因为对象的存在，才在内存中存在。 b)局部变量：存在栈内存中。
阅读全文
摘要：设计模式：解决某一类问题最告之有效的方法，设计模式是纯思想的！ Java中有23种设计模式。一、单例模式（Single）： 解决一个类在内存中只有存在一个对象。想要保证对象的唯一：1，为了避免其他程序过多建立该类对象。先控制禁止其它他程序建立对象！ 2，还为了其他程序可以访问到该类对象，只好在本类中，自定义一个对象！ 3，为了方便其他程序对自定义对象的访问，可以对外提供一些访问方式！代码实现步骤：1，将构造函数私有化。 2，在类中创建一个本类对象。 3，提供一个方法可以获取到该对象。/********************饿汉式************************/package
阅读全文
浙公网安备 33010602011771号