JAVA基础知识巩固篇一

JAVA基础篇一

1、Java中类的继承，其中的static方法，有参无参构造方法调用顺序

我们知道，java中很常见继承的问题，例如student继承自people类，那么在我们使用的过程中，难免会涉及到其构造方法，话不多说，我们先上代码：

public class People {
    public static void main(String[] args) {
        People people = new People();
        System.out.println("********************");
        People people1 = new People(1,2);
        System.out.println("********************");
        Student student = new Student();
        System.out.println("********************");
        Student student1 = new Student(1,2);
    }
    {
        System.out.println("aa");
    }
    static {
        System.out.println("bb");
    }
    public People(){
        System.out.println("cc");
    }
    public People(int x,int y){
        System.out.println("dd");
    }
}
class Student extends People{
    {
        System.out.println("AA");
    }
    static {
        System.out.println("BB");
    }
    public Student(){
        System.out.println("CC");
    }
    public Student(int x,int y){
        System.out.println("DD");
    }
}
输出结果如下：
bb
aa
cc
********************
aa
dd
********************
BB
aa
cc
AA
CC
********************
aa
cc
AA
DD

在java的类中，调用顺序是这样的

1. 加载该类则必须先加载static属性或static代码块（ 静态变量和静态块没有优先级之分。谁在前面先加载谁）

2. 然后，如果有非static的成员属性则再加载非static的成员属性。

3. 如果有非static的代码块则再加载非static的代码块。

在结果一中，首先调用了People的静态方法，输出了bb，而后调用其无参构造方法，输出aa,cc(aa的括号中的语句视为类在实例化中必须优先调用的语句)

在结果二中，应该先调用静态方法，输出bb，然后在输出aa，在调用有参构造方法dd，但是，在一次执行java程序中，只会初始化一次静态变量。因此调用People的有参构造不在初始化其静态方法。

在结果三中，由于bb已经被初始化，因此不输出bb，直接调用子类的静态方法输出BB，由于student继承于people，因此需要先调用父类的无参构造方法，此时需要输出aa,cc，而后调用子类的无参构造方法输出AA,CC

在结果四中，同理，bb和BB已经被实例化，先调用父类的无参构造方法输出aa，cc而后调用子类的有参构造方法输出AA,DD。

我们只需要记住，在一个程序中，调用一个类时会优先初始化其static修饰的变量和代码块，按顺序执行，且在一次执行中只初始化一次，而后才加载类中的其他非静态方法。

2、Final的用法

顾名思义，final，最后的最终的，即不能修改，由此可以想到

1. final修饰的类不能被重写
2. final修饰的方法不能被重写
3. final修饰的变量不能被改变，如果修饰引用，则引用不可以改变，引用的值可以改变

3、Java的基本类型，以及占用的字节问题

java中的基本类型有八种，分别是byte、short、int、long、char、float、double、boolean（String不是Java基本类型）

类型	大小	取值范围
byte	一字节8位有符号整数	-128 - 127
short	二字节16位有符号整数	-2^15 - 2^15-1
int	四字节32位有符号整数	-2^31 - 2^31-1
long	八字节64位有符号整数	-2^62 - 2^63-1
char	2字节16位Unicode字符	0 - 2^16-1
float	四字节32位浮点数	1.4E-45 - 3.4E+38，-1.4E-45 - -3.4E+38
double	八字节64位浮点数	4.9E-324 - 1.7E+308, -4.9E-324 - 1.7E+308
boolean	一字节八位	true,false

Unicode字符码：是Ascll字符编码的拓展，Ascll中每个字符用7位表示，计算机上每个字符8位。Unicode使用全16位字符编码，因此Unicode能表示世界上所有能用于计算机通讯的符号。

Unicode最初是作为Ascll的补充。若字符在Ascll中存在，则一个字节为空（全0），另一个字节为原Ascll码的值。

4、Java中的封装类

Java中有基本数据类型和基本数据类型的封装类，如int和Integer。为了方便将基本数据类型转化为对象进行处理，下面使用一段代码讲解：

public static void main(String[] args){
	Integer a = 100;
	//这里将a进行了自动装箱，封装成了对象，等同于Integer a = new Interger(1); 
	int b = a - 1;
	//这里将b进行了自动拆箱，将Java对象a转化成了基本数据类型然后进行计算。
	int x = 100;
	Integer y = 100;
	int z = 100;
	Integer f = 100;
    Integer g = new Integer(100);
    Integer h = new Integer(100);
    Integer j = 1000;
    Integer k = 1000;
	System.out.println("x == y");//结果为true
    System.out.println("x == z");//结果为true
	System.out.println("y == f");//结果为true
    System.out.println("g == h");//结果为false
    System.out.println("j == k");//结果为false
    //原因是Integer中IntegerCache这个类中的缓存数组cache[]存放内容为-128 - 127的整数，Integer x=100实际在内部做了Integer.valueOf(100),判断是否在这个区间，如果在此区间内，则返回x+128作为cache的下标，放到缓存中。如果不在这个区间，则创建new Integer(x)。即-128 - 127 内不会new生成，超出才另外new Integer()
    //如果是int与int值比较，Integer与int的值相同的比较，结果为true
    //如果是两个Integer=new Integer()比较，总是为false，地址不同
    //如果是Integer a=;Integer b=；若值在-128 - 127间true；不是则为false。
}

5、内部类

内部类的定义

将一个类定义在另一个类里面或者一个方法里面，这样的类称为内部类。

内部类的作用：

1. 成员内部类 成员内部类可以无条件访问外部类的所有成员属性和成员方法（包括private成员和静态成员）。 当成员内部类拥有和外部类同名的成员变量或者方法时，会发生隐藏现象，即默认情况下访问的是成员内部类的成员。

2. 局部内部类 局部内部类是定义在一个方法或者一个作用域里面的类，它和成员内部类的区别在于局部内部类的访问仅限于方法内或者该作用域内。

3. 匿名内部类 匿名内部类就是没有名字的内部类

4. 静态内部类 指被声明为static的内部类，他可以不依赖内部类而实例，而通常的内部类需要实例化外部类，从而实例化。静态内部类不可以有与外部类有相同的类名。不能访问外部类的普通成员变量，但是可以访问静态成员变量和静态方法（包括私有类型） 一个 静态内部类去掉static 就是成员内部类，他可以自由的引用外部类的属性和方法，无论是静态还是非静态。但是不可以有静态属性和方法。

6、JAVA中的可抛出错误

Java可抛出(Throwable)的结构分为三种类型：被检查的异常(CheckedException)，运行时异常(RuntimeException)，错误(Error)。

CheckedException：Java编译器不会检查它。也就是说，当程序中可能出现这类异常时，倘若既"没有通过throws声明抛出它"，也"没有用try-catch语句捕获它"，还是会编译通过。

常见的：

1. ClassCastException （类转换异常）

2. IndexOutOfBoundsException （数组越界）

3. NullPointerException（空指针异常）

4. ArrayStoreException （数据存储异常，操作数组是类型不一致）

5. BufferOverflowException

RunTimeException： Java编译器会检查它。 此类异常，要么通过throws进行声明抛出，要么通过try-catch进行捕获处理，否则不能通过编译。例如，CloneNotSupportedException就属于被检查异常。

常见的：

1. IOException
2. FileNotFoundException
3. SQLException

error：当资源不足、约束失败、或是其它程序无法继续运行的条件发生时，就产生错误。程序本身无法修复这些错误的。例如，VirtualMachineError就属于错误。出现这种错误会导致程序终止运行。

7、Java创建对象的机制

1. new创建对象
2. 反射机制（Mybatis）
3. clone创建
4. 序列化创建

8、Java中的迭代器异常ConcurrentModificationException

出现这个异常的原因是因为在迭代一个list的时候，还同时使用list.remove等方法修改list。如果需要修改值，需要使用迭代器iterator的remove方法，如下代码：

public class Test {
	public static void main(String[] args) {
		ArrayList<Integer> list = new ArrayList<Integer>();
		list.add(2);
		Iterator<Integer> iterator = list.iterator();
		while(iterator.hasNext()){
			Integer integer = iterator.next();
			if(integer==2)
				list.remove(integer);//错误，会报错
            	iterator.remove();//正确修改
			}
	}
}