Java基础知识点总结笔记

面向对象的三大特性

继承：一般只能单继承，内部类实现多继承，接口可以多继承

 

 1 class Meal{
 2         Meal(){
 3             System.out.println("Meal()");
 4         }
 5     }
 6     class Bread{
 7         public Bread() {
 8             System.out.println("Bread()");
 9         }
10     }
11     class Cheese{
12         public Cheese() {
13             System.out.println("Cheese()");
14         }
15     }
16     
17     class Lettuce{
18         public Lettuce() {
19             System.out.println("Lettuce()");
20 
21         }
22     }
23     class Lunch extends Meal{
24         public Lunch() {
25             System.out.println("Lunch()");
26 
27         }
28     }
29     
30     class PortableLunch extends Lunch{
31         public PortableLunch() {
32             System.out.println("PortableLunch()");
33 
34         }
35     }
36     class Sandwich extends PortableLunch{
37         
38         Bread b = new Bread();
39         Cheese c = new Cheese();
40         Lettuce l = new Lettuce();
41         Sandwich(){
42             System.out.println("Sandwich()");
43 
44         }
45          public static void main(String[] args) {
46              new Sandwich();
47 
48          }
49     }

 

解析：子类对象的创建与实例化过程：首选，分配对象所需的全部内存空间，并初始化为0；然后，按继承的关系，自顶向下显示初始化；最后，按继承关系，从顶向下调用构造方法。所以：

　　Meal()

　　Lunch()

　　PortableLunch()

　　Bread()

　　Cheese()

　　Lettuce()

　　Sandwith()

 

封装：访问权限控制public>protected>包>private内部类也是一种封装

多态：编译时多态，体现在向上转型和向下转型，通过引用类型判断调用哪个方法(静态分配)。运行时多态，体现在同名函数通过不同的参数实现多种方法（动态分配）。

重载：

　　一个类中，有若干个方法名相同，但方法的参数形式不同，称为方法的重载。原则：①方法名相同；②方法的参数类型不同，或参数个数不同，或当方法有两个以上参数时，只要参数类型的顺序不同；③与方法的参数名，返回类型和修饰符无关。

基本数据类型

1.基本类型位数，自动装箱，常量池。

2.例如byte类型是1byte也就是8位，可以表示的数字是-128到127，因为还有个0，加起来一共是256，也就是2的八次方。32位和64位机器的int是4个字节也就是32位，char是一个字节就是8位，float是4个字节，double是8个字节，long是8个字节。

3.基本数据类型的包装类只在数字范围-128到127中用到常量的池，会自动拆箱装箱，其余数字范围的包装类则会新建实例。

4.java中直接输入整数则默认为int类型，来带有小数点的实数默认为double类型。如果你直接声明 long a = 123；这是没有错的，因为123是int类型，可以自赋值给范围更大的long类型，但是如果你的数字超过int范围那得告诉编译器，你百的数字已经大于int范围，要换成更大范围的long类型度表示，所以数字后面加上L(或小写l)。比如 long a = 2147483648;(这样写会报错，因为int类型最大表示范围是2147483647) 得这样 long a = 2147483648L;
浮点数一样，后面加的是F/f (代表float类型)

String及包装类

1.String类型是final类型，在堆中分配空间后内存地址不可变。

2.底层是final修饰的char[]数组，数组的内存地址同样不可变。但实际上可以通过修改char[n] = 'a'来进行修改，不会改变String实例的内存值，不过在jdk中，用户无法直接获取char[]，也没有方法能操作数组。所以String类型的不可变实际上也是理论上的不可变。所以我们在分配String对象以后，如果将其 = "abc"，那也只是改变了引用的指向，实际上没有改变原来的对象。

3.StringBuffer和StringBuilder底层是可变的char[]数组，继承父类AbstracStringBuilder的各种成员和方法，实际上的操作都是由父类方法来完成的。

final关键字

1.final修饰基本数据类型保证不可变

2.final修饰引用保证引用不能指向别的对象，否则会报错。

3.final修饰类，类的实例分配空间后地址不可变，子类不能重写所有父类方法。因此在cglib动态代理中，不能为一个类的final修饰的函数做代理，因为cglib要将被代理的类设置为父类，然后再生成字节码。final修饰方法，子类不能重写改方法。

抽象类和接口

1.抽象类可以有方法实现。抽象类可以有非final成员变量。抽象方法要用abstract修饰。抽象类可以有构造方法，但是只能有子类进行实例化。

2.接口可以用extends加多个接口实现多继承。接口只能有public final类型的成员变量。接口只能有抽象方法，不能有方法体，接口不能实例化，但是可以作为引用类型。

相同点：

（1）不能直接实例化。如果要实例化，抽象类变量必须实现所有抽象方法，接口变量必须实现所有接口未实现的方法。

（2）都可以有实现方法（Java8 以前的接口不能有实现方法）。

（3）都可以不需要实现类或者继承者去实现所有方法（Java8 以前的接口，Java8 及以后的接口中可以包括默认方法，不需要实现者实现）。

不同点：

（1）抽象类和接口所反映出的设计理念不同。抽象类表示的是对象 / 类的抽象，接口表示的是对行为的抽象。

（2）抽象类不可以多重继承，接口可以多重继承。即一个类只能继续一个抽象类，却可以继承多个接口。

（3）访问修饰符 ——

• 抽象类中的方法可以用 public protected 和 default abstract 修饰符，不能用 private、static、synchronize、native 修饰；变量可以在子类中重新定义，也可以重新赋值；
• 接口的方法默认修饰符是 public abstract， Java8 开始出现静态方法，多加 static 关键字；变量默认是 public static final 型，且必须给其初值，在实现类中也不能重新定义，也不能改变其值。

（4）抽象类可以有构造器，接口没有构造器。

代码块和加载顺序

假设该类是第一次进行实例化。那么有如下加载顺序

静态总是比非静态优先，从早到晚的顺序是：

1.静态代码块和静态成员变量的顺序根据代码位置前后来决定。

2.代码块和成员变量的顺序也是根据代码位置来决定

3.最后才调用构造方法。

包，内部类，外部类

1.Java项目一般从src目录开始有com...A.java这样的目录结构。这就是包结构。所以一般编译后的结构是根包结构一模一样的，这样的结构保证了import时能找到正确的class引用包访问权限就是指同包下的类可见。

import一般加上全路径，并且使用.*时只包含当前目录的所有类文件，不包括子目录。

2.外部类只有public和default两种修饰，要么全局可访问，要么包内可访问。

3.内部类可以有全部访问权限，因为它的概念就是一个成员变量，所以访问权限设置与一般的成员变量相同。

非静态内部类是外部类的一个成员变量，只跟外部类的实例有关。

静态内部类是独立于外部类存在的一个类，与外部类实例无关，可以通过外部类.内部类直接获取Class类型。

异常

1.异常体系的最上层是Throwable类。子类有Error和Exception。Exception的子类又有RuntimeException和其他具体的可检查异常。

2.Error是jvm完全无法处理的系统错误，只能终止运行。运行时异常指的是编译正确但运行错误的异常，如数组越界异常，一般是人为失误导致的，这种异常不用try catch,而是需要程序员自己检查。可检查异常一般是jvm处理不了的一些异常，但又经常会发生，比如Ioexception,Sqlexception等，是外部实现带来的异常。

3.多线程的异常流程是独立的，互不影响。大型模块的子模块异常一般需要重新封装成外部异常再次抛出，否则只能看到最外层异常信息，难进行调试。日志框架是异常报告的最好帮手，log4j，slf4j中，在工作中必不可少。

泛型

1. Java中的泛型是伪泛型，只在编译期生效，运行期自动进行泛型擦除，将泛型替换为实际上传入的类型。

泛型类用classA {

}

2. 这样的形式表示，里面的方法和成员变量都可以用T来表示类型。泛型接口也是类似的，不过泛型类实现泛型接口时可以选择注入实际类型或者是继续使用泛型。

3. 泛型方法可以自带泛型比如void go();

泛型可以使用?通配符进行泛化 Object可以接受任何类型

也可以使用 这种方式进行上下边界的限制。

Class类和Object类

1. Java反射的基础是Class类，该类封装所有其他类的类型信息，并且在每个类加载后在堆区生成每个类的一个Class<类名>实例，用于该类的实例化。

2. Java中可以通过多种方式获取Class类型，比如A.class,new A().getClass()方法以及Class.forName("com.?.?.A")方法，使用 clone 方法，使用反序列化。

3. Object是所有类的父类，有着自己的一些私有方法，以及被所有类继承的9大方法。

 

 未完待续。。。