Java学习笔记

（代理和适配器）
1.java中不能重载运算符
2.java 接口为了规范类的行为，抽象类则是不同行为可以用抽象方法表示
3.java中的常数定义  private final static int a=0;
4.java中静态变量和静态方法（类中的静态变量被此类的所有对象共享，静态方法通过类名调用，一般对静态成员做处理）
5.在java中任何类都是Object的子类，可以重写Object中的toString方法，将对象转化为字符串
6.在java中位运算很少用到，a<<b相当于a*2的b次幂 ,没有？ ：；三目运算符，字符串的比较==表示存储空间和字符串都相同，若一个字符串是另一个字符串的子串，则前者小于后者，如果一个字符串不存在前者关系，从第一个不相同的字符开始比较ascall吗值，判断两个字符串是否相同用equals
7.字符串通过调用.toCharArray()返回一个字符数组
Charater.toLowerCase('字符'); 将字符小写
8.Java中提供了构造器来创建实例，并提供垃圾自动回收的功能。构造器可以重载，new 构造器则在堆中申请一片连续的存储单元用于实例化对象，也有默认的构造器
9.Java中this指针的使用主要包括1）当实例对象调用某个方法时，this指针会指向此对象，对this指针的操作相当于对调用者的操作
2）在重载构造器中使用其他构造器通过this（）
10.C++中有构造器和析构器，分别完成创建对象时执行的操作和释放对象所在内存之前执行的操作
Java中有构造器与C++中构造器同理，Java中却无析构器，只有一个finalize（）方法执行垃圾回收站回收内存前的操作
11.在使用finalize方法时首先要继承于Object（调用super.finalize（）的方法）添加垃圾回收站收回对象内存前完成的操作，而垃圾回收站的基本原理，当对象初始化时，引用计数+1，当对象制空时引用计数器-1，当执行到System.gc()；垃圾回收站会检查所有对象的引用计数，如果发现某个对象引用计数为0则调用finalize（）。
12.在Java中对于静态成员变量的初始化，尅直接在定义处初始化，也可以显示的在static块中初始化
13.数组的初始化 例如 int []a=new int[10]或者{1,1,2,3,4,}
或者int[] a=new int[]{};
14.可变数组的初始化
Object... objs
15.创建一个Enum枚举类型，
16.多用组合少用继承，组合中的引用对象可以有下列几种常用初始化情况
1）在类中定义处
2）在构造器中初始化‘
3）在需要使用的地方手动初始化
4）直接付引用
17.继承的语法
1）基类被派生类继承通过extends标识
2）派生类中添加新属性，新方法，构造器中首先需要对基类初始化super，再对子类初始化
3）super.xxx()通过super关键字来调用父类的方法
18.final用法
1）final修饰字段  static final 定义常量，static 定义静态变量
2）final修饰方法  表示此方法不被覆盖
3）final修饰类  表示此类不能被继承
19.少用继承多用组合
如果需要向上转型，必须用继承
20.java中如果是基类中的方法为静态方法，且派生类中的方法为静态方法，则向上引用失效，实际对象调用的任然是基类中的方法
21.java中构造器的顺序，首先调用基类的构造方法，然后对自身成员变量初始化，最后执行方法体类的信息
22.一般不考虑空间的释放，默认垃圾回收站已完成了此事
23.继承过程中可能出现的错误，派生类构造器中调用基类的构造器，若基类构造器中存在覆盖方法的调用则会跳过基类的方法，转而调用派生类中的此方法，产生错误的结果
24.java中的一条准则，通过继承表达行为上的差异，用字段表达状态的改变
25.java中的向下转型要相当的小心，必须知道其类型
26.java中抽象类和接口的差异与联系，抽象类主要是为了说明一类实物的共同特征，而接口提供公共的方法接口体现行为的差异，抽象类中一定存在抽象方法，可以存在以实现的方法，而接口中只存在没有函数体的方法
面向接口编程和面向抽象类编程思路一样
27.抽象类不能创建实例，但是能面向抽象类编程
28.接口中只能定义常量和公共方法接口。
29.当利用接口实现基本的多继承时，必须具体类放接口前面
30.接口的继承，行为接口的扩展，实现类必须都实现（在打算组合的不同接口中使用相同的方法名通常会造成代码可读性的混乱，避免此种情况产生）
31.在接口中能定义接口，或者类中定义接口，比如A类中存在B接口则一个实现类实现B接口需表示成为A.B
32.接口与工厂模式的结合
33.内部类的意思是在一个定义好的类中定义一个新的类，在外部类中可以使用内部类，而且外部类中必须存在一个返回内部类引用的方法
34.外部类中的所有元素可以被内部类引用
35.在内部类中获得外部类的引用通过外部类名.this来表示一个外部类的引用
36.通过外部类A获得内部类B的实例，首先创建一个外部类的引用a,然后通过A.B b=a.new B();创建了一个内部类实例，
37.当将内部类设置成private类型时便不能通过上一条方法获得内部类的实例，只能通过调用外部类中返回内部类引用的方法获得内部类，降低了类与类之间的耦合性
38.在任何作用域下定义内部类，其和其他类都是一起编译，只不过是超过其作用域之后不能使用。作用域可以在一个方法内部，也可以在一个条件与中
39.所谓的匿名内部类指的是在一个外部类中存在方法，在方法中有产生某个类的实例时直接在定义语句后面添加此类的定义；结束
40.如果外部方法需要向匿名内部类传值则需要将此形参设置为final
41.由于在匿名内部类中压根没有名字，所以定义内部类的构造器{构造器的操作     }表示.
42.当基类中存在非默认的构造器时，注意在创建扩展类对象时调用带参数的构造器（基类构造完成，再构造扩展类中的域）
43.匿名内部类与工厂模式的结合，有一个Service接口，一个对应的ServiceFactory接口，包括两个Service实现类（均为内部类），里面有个属性为Factory通过匿名内部类实现ServiceFactory接口。（优先使用类而不是接口）
44.如果不希望内部类与外部类之间存在联系，那么可以将内部类设置static，通常称为嵌套类（1.要创建嵌套类对象时，并不需要其外围类的对象
2.不能从嵌套类的对象中访问非静态的外围类对象，3.不能在嵌套类中通过外部类名.this获得外部类的引用4.接口中可以放置嵌套类）
45.无论内部类嵌套多少次，永远是从外部类向内访问，内部类主要用于实现多继承（闭包的作用）
46.关于内部类的继承extends A.B形式，构造器必须为X（A a){ a.super()) ,a.super()表示调用B的构造器
47.ArrayList和LinkedList中加入顺序和遍历的顺序一致,ArrayList一般作为随机访问多，LinkedList一般做插入比较多，效率比较高.Set与Map加入顺序和遍历顺序不一致。
48.当需要添加一组数据时，可以先将这组数据转化成为一个数组array，然后利用Arrays.asList(array)将数组转化成为List.同时可以将一个List转化成为一个序列对象
除此之外也可以通过Collection序列来添加一组数据,先将这组数据保存在数组array中，创建一个Collection 实例=向上转型，Collections.addAll(collection,array)
49.在输出格式中List，Set的表示形式是【元素1，元素2】（特别注意Collection，List，Set，Queue，Map均为借口所以不存在实例，只能向上转型），而且在List允许相同元素存在，而Set不允许相同元素存在（集合）
在输出格式中Map的表示形式是{key1=value1,key2=value2,key3=value3}
50.List接口中的常用方法IndexOf(对象)返回该对象所在列表中的索引号，contains(对象)对象是否存在列表，subList(beginIndex,count)返回一个子列表，A.containsAll(B)A列表中是否包含B列表的全部元素，A.addAll(B)将B子串加到A子串的最后，toArray()将列表转化成为数组
51.Java中每个容器均有对应的迭代器Iterator，容器list.iterator();返回指向第一个元素的迭代器，hasNext()是否存在下一个元素，next()返回迭代器指向的下一个元素，iterator.remove()删除迭代器所指向的元素
list.listIterator()返回一个可以前后移动的迭代器，通过provious()和next（）分别取得迭代器所指向的元素的前一个元素和后一个元素
52.Set接口保证不存在重复的元素，主要有下面三种实现HashSet，TreeSet，LinkedHashSet，HashSet采用散列函数保证查找速度，TreeSet通过红黑树结构（排序），LinkedHashSet采用散列函数，类似于链表的结构（维护元素的插入顺序）
53.Map接口主要的实现类是HashMap保证查询的速度，采用散列函数，不保存添加的顺序而且keySet()(key值得序列),values()（value值得序列）,containKey()(map中是否存在此key值)，containValue（）（map中是否存在此value值），TreeMap（按照红黑树来存储，保证按照key值大小排序），LinkedHashMap（按照散列函数，保存插入顺序）
54.Queue可以由LinkedList来向上转型而成，调用offer方法可以将元素插入队尾，保留插入顺序，先进先出，peek（）时可以返回对头，poll（）移除并返回对头
55.异常情况指程序执行过程中不能继续向下执行而停下来的情况，普通问题可能是编译过程中就能解决的问题，可以根据提供的信息给出解决方案，但异常情况也需要给出出了问题应该怎么做，即异常处理程序，保证做完处理之后程序能继续向下执行。
56.异常处理机制过程，当Java程序中产生异常，则会动态生成一个异常对象，并由系统抛出，由异常处理程序来接受异常并执行异常处理程序，保证程序继续向下执行
57.Java中存在的两种异常处理的模型（终止模型，恢复模型），对于一些重大的运行错误，无法解决则可以让程序直接抛出异常程序终止。而恢复模型指当发生一般异常时，不然其抛出，catch到并执行异常处理程序，最终返回继续执行程序
58.Java允许开发者自定义异常类（但必须继承已有的异常类），throw new 异常类（）表示产生一个异常对象，throws 异常类表示如果产生一个异常实例，则抛出，e.printxxx(System.out)表示在控制台输出发生此异常的行数,e.getMessage()返回e构造器传递进去的参数
59.Java中允许日志记录异常信息，在新派生的异常类中设置一个静态的Logger实例，Logger logger=Logger.getLogger("xxx")发现或者产生名为xxx的日志对象，在新异常类中的构造器中StringWriter sw=new StringWriter()获得写入的信息对象，printxxx打印出所在列信息，logger.severe(trace.toString)向日志中写入严重异常信息
60.Java异常处理程序e.getMessage()返回初始化时的String信息，e.getClass(),e.getName(),e.getSimpleName(),e.toString(),e.printStackTrace()
61.e.getStackTrace()由于程序执行的每一步均被保存在stackTrace中，每一帧则为一个记录，返回一个帧的stack，ste.getMethodName()可以返回每个记录所调用的方法的记录。
62.抛出重复的异常，则异常对象会被上层的catch捕获到，printStackTrace（）打印发生异常的列号，即使向上层继续抛出，保留的异常的位置任然不变。若要更新发生异常的位置，则应该throw （Exception）e.fillInSackTrace()
63.异常链一般用在当catch了一个异常之后，抛出新的异常需要保留之前的异常对象则会形成一个异常链，新抛出的异常对象.initCause(以前的异常对象)形成一条异常链
64.RuntimeException是个异常类中的特列，当抛出RuntimeException时会直接交给System.err处理，并调用printStackTrace（）返回发生异常的位置
65.finally结构无论try中发不发生异常，finally中的语句一定被执行，一般做清理操作比如调用对象.close()等等
66.构造器中如果发生异常，一般是创建需要清除的对象时可能发生异常，则需要在后面紧跟try-finally结构，finally中做该对象的清理工作。
67.try-catch的匹配原则，当try中抛出的异常对象与最近的一个catch中异常类是其对象类的基类或者自身类，则就近被匹配，做异常处理程序
68.字符串对象初始化过程,字符串的操作实际上是保持以前String对象不动，而创建一个全新的String对象（通过DOS输入javap -c 类名可以对此类进行反编译）
1）String cde = "cde";
2）char data[] = {'a', 'b', 'c'};
   String str = new String(data);
3）String s=new String("caiqi");
69.常用方法lastIndexOf("x")从后向前搜索返回字符x第一次出现的位置，concat（“abc”）在返回原有字符串基础上再在尾部加上abc字符，trim()去掉两端的空白字符，valueOf(xyz)返回形参的内容
70.Java中允许通过Formatter(PrintStream或者PrintWriter) 通过对象来调用format(字符串)定义字符串输出的目的地，可以修改输出的格式通过format（）主要通过格式符%d 整形，%c Unicode字符，%b Boolean ,%s String ,%f 浮点数，%e浮点型（科学记数法）,%x 整数，%h 散列码（十六进制）
String.format()  返回一个格式化之后的字符串
71.正则表达式是一种文本处理工具，可以作为字符串的规范，理解语法，//d表示插入一个数字，？表示若干，-表示负，+表示+，|表示或，判断一个字符串是否符合相应的数据格式可以使用s.matches("正则表达式规定的格式")，//W表示非单词字符，n//W表示字符n后面非单词字符，split（“可以使正则表达式”），如果满足正则表达式的形式则立即分割，最终会返回分割后的字符串的数组，//w表示一个或多个单词字符，
72.正则表达式一般被用在{matches（）判断字符串是否符合规范，spilt（）当满足这个正则表达式条件时则拆分字符串，replaceFirst或者replaceAll（"正则表达式"，“替换字符串”）当满足这个正则表达式的格式时则将其替换}
73.Matcher中的reset（）允许将matcher从新指向起始位子，Matcher中有一个groupCount（）返回匹配字符串的组数，.group(i)返回第i组数据
Pattern pattern=Pattern.compiles("正则表达式")；Matcher m=pattern.matches("检验字符串")；(从头检验)；m.find()返回是否满足正则表达式规范
74.扫描字符串通过Scanner
Scanner scanner=new Scanner("扫描的字符串");
scanner.useDelimiter(“元素的分隔符”)；
while(scanner.hasNext()){
scanner.next();  获得元素
}
当Scanner与Pattern结合，即正则表达式来判断时
Scanner scanner=new Scanner("扫描的字符串");
Pattern pattern=Pattern.compile("正则表达式")；
while（scanner.hasNext(pattern)）{
scanner.next(pattern);
MatcherResult match=pattern.matches();
match.group(1);
}
75.类型信息包括两种情况，一种是RTTI指在编译时便知道所有的类型信息，第二种则是反射，在运行或者使用时才知道类型信息
76.Class对象的引用，Class.forName("类名")获得该类所对应的.class 文件的引用，getClass（），只有类加载器加载了某个类所对应的字节码文件.class文件至内存中才能创建此类的实例
77.另外一种获得字节码文件引用的是直接在类的后面.class称为类字节常量，int.class等价于Integer.TYPE
78.Class c=xxx.class,之后又通过c=yyy.class这种情况会在编译的时候通过，为了避免这种情况使用泛型类来Class<Integer>c=int.class,若c=boolean.class则在编译时就会报错当然同样支持向上转型，为了放松这种约束，使用Class<?>c通配符，表示你使用了一种非具体的引用，比如当你使用Class<? extends Number> c=xxx.class则规定xxx类只能是Number类的子类，可以通过c.newIntance()获得xxx的对象引用，同样也可以Class<? super Number> c=yyy.class规定yyy类必须是Number类的超类
79.由于Java中的类型转换只能是向下转化，在编译的过程中无法确定某个对象的类型，因此可以通过xxx instanceof YYY的实例，则可以向下转化（YYY）xxx
80.由于对一个字节码文件引用列表计数其每一个字节码文件的个数，Map(字节码的对象，count)
isInstance用法，Map中pair的用法参加ClassDemo7
81.Java中允许使用泛型比如在使用工厂模式时Factory<T>{ T create();},
82.isInstance(),Class    XXX.class.isInstance(xxx)   XXX.class==xxx.getClass    XXX.class.equals(xxx)
83.RTTI在编译期间知道类型信息，反射则是在运行期间知道其类型信息。Class.forName("xxx")获得xxx名的字节码文件引用，或者XXX.class则可以获得其类型信息包括此类实现的接口，超类，方法数组，构造器数组等等内部信息
84.动态代理，空对象，接口与类型信息  假设在interface A{public  f();private g();protect v();},某个class C implements A{ f(),g(),v()}.在主函数中A a=new C();通过a.getClass()获得其字节码文件.Method m=getDeclaredMethod("f|g|v"),m.setAccessible(true)(修改其方法的访问权限),m.invoke(a)(等价于a.m())
85.泛型类的用途避免代码的重复，以及增加利用率，面向抽象编程，在初始化具体实例对象时需要指定其类型。允许使用元祖
86.泛型接口interface Generator<T>{ T create();}
87.泛型方法不用在意类是不是泛型类，public <T> 返回值类型 方法名（参数值类型 对象）{}
88.设计一个基本的工厂实例BaseFacoty<T> implments Factory<T>{
private Class<T> type;   //定义一个字节码文件
构造器;
public <T> T create(){
return type.newInstance();
}
89.利用泛型方法代替泛型类
public class Tuple{
static <A,B> TwoTuple<A,B> tuple(A a,B b){
return new TwoTuple(a,b);
}
}
90.匿名内部类中可以使用泛型类
91.在编译的过程中，泛型类会被擦拭成非泛型类比如Person<T>会被擦拭成Person类
92.Array.newInstance(字节码文件对象，10)则生成10个对象的数组
93.泛型数组的使用，T[] array=new T[];(编译发生错误)必须将其转化为擦拭后的类型T[] array=(T)new Object[];
94.泛型类可以设置其界限  List<T extends Animal>规定其上界即泛型类只能是Animal的派生类，List< T super Animal>规定其下界即泛型类只能是Animal的基类
95.List<? extends Animal>=new ArrayList<>();由于在编译期间不知道使用的是Animal的哪个派生类，所以添加操作时编译不能通过
List<? super Animal> 由于JAVA中只存在单继承，只有一个确定的基类，所以能添加信息
<?>任意类型，编译能通过
96.JAVA中泛型类的类型不能为基本数据类型，只能为其对应的基本数据类型的封装类，List<Integer> list诸如此类，添加的时候可以添加int，foreach循环的时候也可以for(int i:list)遍历，JAVA中可以完成基本数据类型和封装类之间的任意转化
97.在泛型类中如果要用readObject(),一般都需要用到cast（），XXX.class.cast(z.readObject());安全
98.当泛型类中存在仅仅参数诸如List<A>,List<B>不同的情况下，由于参数要在编译期间被擦除，一般不能用重载方法
99.B<T extends List<T>>诸如此种情况下的泛型类，List<T>作为T的上界，T又限制了List<T>类型，双重限制
100.泛型类中的自限定情况指若基类class B<T extends B<T>>{}存在双重约束,则规定基类的子类必须为class A extends B<A>{}
101.动态检查，List<Dog> dog1=new ArrayList<>();List<Dog> dog2=Collection.checkList(new ArrayList<Dog>(),Dog.class);对List进行动态的检查A(List list){list.add(new Cat())}第二种会抛出异常
102.数组相对于容器ArrayList而言，存取的效率高的多，唯一的缺点是数组的大小是固定的，对象数组保存的是引用，而基本数组保存的是值
103.把数组作为返回值时，直接诸如String[] 返回值定义为字符串数组。
104.三维数组的输出结果int[][][] a=new int[2][3][4] deepToString(a)[[[a,b,c,d],[a,b,c,d],[a,b,c,d]],[[a,b,c,d],[a,b,c,d],[a,b,c,d]]]类似
105.动态生成数组比如二维数组int[][] i=new int[2][]可以先指定数组的行，a.length表示行的个数，a[i]表示第i行=new int[3],a[i].length=3表示第i行的列数为3列
106.泛型类与数组的同时使用比如List<String>[] lists=(List<Stirng>[])new List[10],这样一个存放String对象的列表的数组初始化成功
107.数组的复制通过若int[] a1=new int[7];int[] a2=new int[10];a1复制给a2,则System.arraycopy(a1,0,a2,0,a1.length);System.out.println(Arrays.toString(a2));
108.比较两个数组是否相等Arrays.equals(a1, a2);
109.Arrays.sort(XXX[])对于XXX类型的数组排序（由小到大）,实则按照一定的规律比较数组中的各元素从而排序，给出各元素比较的标准XXX implements Compareable<XXX>{实现compareTo(XXX x)方法}对于compareTo()实际上就是两个XXX对象之间比较的标准
110.对于进程而言是一个动态的概念，表示程序运行的过程，是资源分配的基本单位，由程序，数据，进程控制块组成。对于线程而言，表示程序执行的一个分支，是调度的基本单位，一次只能有一个线程被cpu执行
111.定义一个线程推荐实现runnable接口，Thread t=new Thread(r);t.start();
112.创建线程对象 .start()启动线程则此线程会进入就绪队列，等待cpu调度，若cpu调度则进入执行状态，遇到特殊情况会进入柱塞状态,柱塞可以被唤醒之后进入就绪队列。
113.Thread中存在isAlive()判断线程是否存活，setPrority()设置线程的优先级，sleep()方法让线程进入睡眠状态,join合并线程，yield收回cpu的使用权,当run（）执行结束则线程执行完毕,可以设置一个状态变量flag =true，当睡眠打断后会抛出异常，try-catch处理
114.sleep()方法表示线程睡眠刮起，当苏醒后立即被cpu调用。thread.interaptor()打断线程，若子线程处于睡眠中则会抛出异常，return 结束子线程
join()表示thread.join()表示先执行子线程，后返回主线程
yield()收回cpu的使用权返回就绪队列
115.常见的网络编程一般是指socket编程，包括客户端和服务器端编程，一般写服务器端程序，首先定义一个ServerSocket ss=new ServerSocket(port);指明ss监听的端口号，再写客户端程序，Socket s=new Socket("对方IP"，port);由客户端向服务器端port端口发送一个连接的请求，在服务器端ss检测到此请求,Socket s=ss.accpet();允许此连接请求，创建一个服务器端的插座与客户端通信，这样服务器端和客户端建立了连接。
116.当需要客户端发送一个信息时，通过插座获得链接的输出流通道OutputStream os=s.getOutputStream();将这个通道封装创建一个数据输出流通道DataIOutputStream dos=new DataOutputStream(os);dos.writeUTF("")这可以向此数据输出流通道中写入字符串,客户端也需要通过同样的道理创建一个数据输入流通道dis.readUTF();读取在数据流中的字符串，阻塞式即一直等待直到有字符串过来
117.在服务器端调用s.getPort()获得客户端的端口号，s.getInetAddress()获得客户端的IP地址
118.Scanner in=new Scanner(System.in)当创建一个系统输入的扫描仪,String s=in.next();当有字符串输入时获得键盘输入的字符串
119.java中流的概念可以理解成数据源与程序之间的连接的管道，流的分类输入流，输出流。四个基本的抽象类字节流输入类InputStream,字节流输出类OutputStream,字符流输入类Reader,字符流输出类Writer。前面为节点流最基本的流，完成与一些特殊数据源交换数据管道称为处理流。根据不同的数据源分成不同的处理流.InputStream类中方法int read()从流中读取数据（一个字节一个字节读），int read(byte[] buffer)将从流管道中读取的字节流数据 存放在buffer字节数组中
OutputStream的write();将数据写入字节流中，void write(String string)将字符串string写到字符流中，Reader中的read（）与InputStream中的read（）功能相似，只不过是字符流
120.若想要一个字节一个字节的读一个文件则需要使用字节流输入类FileInputStream(),创建一个此流对象，相当于把一个管道接在了此文件上，通过read（）读一个字节的数据返回值即为读的一个字节的数据，只要返回值不为-1就说明文件未读取完。
文件的copy 不仅需要用到字节输入流类，还需要用到字节输出流类FileOutputStream类为另外一个文件创建一个流对象相当于把一个写入的管道接在文件上，可以把由read（）读取的一个字节的数据通过write（buffer）写入此文件
121.FileReader FileWriter每次读或写一个字符的数据，File这些类都是节点流（直接接到数据源上的流对象）
122.常见的一个处理流BufferReader,BufferWriter,BufferInputStream,BufferOutputStream,缓冲流，相当于在以前流的基础上再套一层缓冲流，对于读而言则不必一个字符一个字符读，允许一行一行读，对于写而言可以写入.nextLine()换行
123.转化流实际上也是一种处理流，套在节点流上，比如OutputStreamWriter 即是将OutputStream字节流转化成Writer的字符流的转化流，转化后允许写入一个字符串,在创建文件输出流时通过构造方法可以设置第二个参数为true（即在原文件内容后面加上新写入的内容），创建转化流也可以通过构造器来指定其字符编码
124.另外一个处理流PrintStream,PrintWriter即打印字节输出流，打印字符输出流.System.setOut()改变输出的对象.
125.最后一个处理流ObjectInputStream，ObjectOutputStream需要将对象所对应的类设置成为可序列化的类