Java重要知识点总结

*编码规范：常量名通常使用大写字母，中间使用下划线连接
*定义的final变量属于全局变量时，必须在定义时就设定它的初值，否则将会产生编译错误。局部变量可以不在定义的时候赋初值（但是在使用前必须赋初值）。
*普通的成员变量（全局变量），可以为它设置初始值，也可以不设置初始值。如果不设置初始值，则会有默认值
*局部变量在使用时必须进行赋值操作或被初始化，否则会出现编译错误
*java.lang.StringBuilder
append(String str);insert(int offset,String str)
delete(int start,int end)
*在java中数组是对象
int array[]
int[] array([]表示要创建的是数组类型)
int a[][]=new int[3][4];//给数组开辟内存空间，同时全部赋初值为0
*abstract修饰的方法子类继承必须重写
final修饰的方法子类继承不能重写
*在接口中定义常量时，该常量的修饰符为final和static；定义方法全部默认为public和abstract修饰
*使用return关键字后，方法的执行将被终止
*在Java语言中规定使用this关键字来代表本类对象的引用，
this引用的就是本类的一个对象，this关键字被隐式的用于引用对象的成员变量和方法，this还可以作为方法的返回值，返回的是本类的一个对象
*静态数据与静态方法的作用通常是为了提供共享数据或方法，静态成员同样遵循着public、private和protected修饰符的约束
*非静态方法中可以调用静态成员和方法，静态方法中不可以直接调用非静态方法（但可以通过对象调用非静态方法），因为非静态不依附于类还没有被初始化，在静态方法中也不可以使用this关键字
*不能将方法体内的局部变量声明为static
*静态代码块会首先被执行，并且只执行一次，通常用于执行类的初始化
*静态内部类和非静态内部类
（1）内部静态类不需要有指向外部类的引用。但非静态内部类需要持有对外部类的引用。
（2）非静态内部类能够访问外部类的静态和非静态成员。静态类不能访问外部类的非静态成员。他只能访问外部类的静态成员。
（3）一个非静态内部类不能脱离外部类实体被创建，一个非静态内部类可以访问外部类的数据和方法，因为他就在外部类里面。
*Java中声明一个对象的时候其实是一个引用，引用的内容是相应对象的内存地址
*int num=Integer.parseInt("12345");
Integer num=Integer.valueOf("12345");
String numStr=num.toString();
*子类不能通过super调用父类修饰为private的方法
*重写可以修改修饰权限，但是只能由小范围到大范围修改
*重写可以修改返回值类型，但必须是父类返回值类型的子类
*在实例化子类对象时会先实例化父类对象，然后再实例化子类对象
*在实例化子类对象时，父类无参构造方法将会自动调用，但有参构造方法并不能被自动调用，只能依赖于super关键字显示地调用父类的构造方法
*把子类对象赋值给父类类型的变量，这种技术被称为“向上转型”
*由于向上转型总是从一个较具体的类到较抽象的类的转换，所以它总是安全的，如可以说平行四边形是特殊的四边形，但不能说四边形是平行四边形
*当在程序中使用向下转型技术时，必须使用显示类型转换（强制类型转换），向编译器指明将父类对象转换为哪一种类型的子类对象
*在执行向下转型之前需要养成一个良好的习惯，就是判断父类对象是否为子类对象的实例。这个判断通常使用instanceof操作符来完成。可以使用instanceof操作符判断是否一个类实现了某个接口，也可以用它来判断一个实例对象是否属于一个类。
*在谈到参数个数可以确定两个方法是否具有重载关系时，会想到定义不定长参数方法，在参数列表中使用“...”形式定义不定长参数，其实这个不定长参数a就是一个数组，编译器会将（int...a）这种形式看作是（int[]a）（这里不是十分准确，使用（int...a）做参数运行传入的参数个数可以为0）
*如果声明一个抽象的方法，就必须将承载这个抽象方法的类定义为抽象类，不可能在非抽象类中获取抽象方法。换句话说，只要类中有一个抽象方法，此类就被标记为抽象类。但是抽象类中是可以包含非抽象方法的
*抽象类被继承后必须实现其中所有的抽象方法，也就是保证相同的方法名称、参数列表和相同的返回值类型创建出非抽象方法，当然也可以是抽象方法
*java中规定类不能同时继承多个父类，但是可以同时实现多个接口，实现接口需要重写接口中的所有方法
*接口也可以进行向上转型操作，也就是说接口也可以定义对象，并且可以使用实现该接口的类定义的对象对接口定义的对象进行实例化。这里类定义的具体方法将会覆盖接口中的该方法。
*在java中无论是将一个类向上转型为父类对象，还是向上转型为抽象父类对象，或者向上转型为该类实现接口，都是没问题的
*当使用import指定了一个包中的所有类时，如果用到这个包中的子类，需要再次对子包做单独引用
*import还可以导入静态成员，例如：improt static java.lang.System.out;
*final关键字定义的变量必须在声明时对其进行赋值操作（声明为final的成员变量可以在构造方法中进行初始化，一个既是static又是final的字段只占据一段不能改变的存储空间，在装载时被初始化，而不是每次创建新对象时被初始化
*定义为final的方法不能被重写，定义为final的类不能被继承，如果将某个类设置为final形式，则类中的所有方法都被隐式设置为final形式，但是final类中的成员变量可以被定义final或非final形式
*内部类的成员只有在内部类的范围之内是可知的，不能被外部类使用。在内部类中可以随意使用外部类的成员方法和成员变量
*对一个内部类进行实例化的操作
OuterClass out=new OuterClass();
OuterClass.innerClass in=out.new innerClass();//需要使用外部类的对象来创建其内部类的对象
*内部类的权限修饰符的作用和成员变量和方法是一样的，如果修饰为private就说明只有当前的外部类可以引用该内部类，其他类都不可以使用
*通常会在外部类中定义一个实现某接口的private类型的内部类，然后再在外部类中定义一个返回那个接口对象的成员方法，这样可以很好的隐藏内部类的实现细节
*成员内部类，就和成员变量和成员方法的定义位置和访问类似
*局部内部类（内部类不仅可以在类中进行定义，也可以在类的局部位置定义，如在类的方法或任意的作用域中均可以定义内部类）
*定义在成员方法中的内部类，在该成员方法的外部不能访问该内部类，但是该内部类可以访问当前代码块的常量以及此外部类的所有成员
*匿名内部类
Interface OuterInterface{
public int getValue();
}
class OuterClass{
public OuterInterface doit(){
return new OuterInterface(){
private int i=0;
public int getValue(){
return i;
}
};
}
}
等价于
Interface OuterInterface{
public int getValue();
}
class OuterClass{
private class InterClass implements OuterInterface{
private int i=0;
public int getValue(){
return i;
}
OuterInterface getInterface(){
return new OuterInterface();
}
}


public OuterInterface doit(){
new InterClass().getInterface();
}
}
在doit()方法内部首先返回一个OuterInterface的引用，然后在return语句中插入一个定义内部类的代码，由于这个类没有名称，所以这里将该内部类称为匿名内部类。实质上这种内部类的作用就是创建一个实现了OuterInterface接口的匿名类的对象。
*静态内部类
一个静态内部类中可以声明static成员，但是在非静态内部类中不可以声明静态成员；静态内部类不可以使用外部类的非静态成员；如果创建静态内部类的对象，不需要其外部类的对象；StaticInnerClass$Inner表示Inner是StatiInnerClass的一个内部类


当try代码块中的语句发生异常时，程序就会调转到catch代码块中执行，执行完catch代码块中的程序代码后，将继续执行catch代码块后的其他代码，而不会执行try代码块中发生异常语句后面的代码。由此可知，Java的异常处理是结构化的，不会因为一个异常影响整个程序的执行。
throws关键字通常被应用在声明方法时，用来指定方法可能抛出的异常；throw关键字通常用于方法体中，并且抛出一个异常对象。
*枚举类型其实也是一种类，如果在类内部创建枚举类型会被作为内部类使用，它相当于继承与java.lang.Enum类，当定义一个枚举类型时，每一个枚举类型成员都可以看作是枚举类型的一个实例，这些枚举类型成员都默认被final,public,static修饰，所以当使用枚举类型成员时直接使用枚举类型名称调用枚举类型成员即可。
*在java中ArrayList<E>,HashMap<K,V>,HashSet<E>,Vector<E>这些集合框架已经被泛型化了，可以直接实例化，例如：ArrayList<Integer> array=new ArrayList<integer>():
*限制泛型可用类型
1.class 类名称<T extends anyClass>
2.使用类型通配符
泛型类名称<? extends List>a=null;
3.继承泛型类和实现泛型接口
*泛型的类型参数只能是类类型，不可以是简单类型，如A<int>这种泛型定义就是错误的
*流是一组有序的数据序列，根据操作的类型，可分为输入流和输出流两种。I/O流提供了一条通道程序，可以使用这条通道把源中的字节序列送到目的地。