JAVA SE重点知识点串讲总结_panfanglin

Java SE 重点知识点串讲总结

下面从多态开始——>

多态（polymorphism）：多态只有方法多态，没有属性多态。
用父类类型屏蔽子类之间的差异


所有的子类对象都可以当父类对象来用，一个父类型的引用可能指向的是一个子类对象，
如：把狗（对象）看作动物（类型）。Animal a=new Dog();        编译看前面，运行看后面。
（编译时类型） （运行时类型）
1，运行时对象不会改变（对象是客观存在的），如：狗这个对象的属性和方法是不会改变的。
2，对一个引用，只能调用编译时类型里的已知方法。
如：编译器知道动物里已有的属性和方法，但不知道狗的属性和方法。
3，运行时会根据运行时类型自动寻找覆盖过的方法运行。

批注 [U8]: （java 最主要的特
性，实现的原理是因为有 jvm
虚拟机，在编译时不用考虑真
实的对象，运行时才考虑，象
封装继承在 c++中都可以模
拟实现，而多态无法实现）

引用 instanceof 类名



／／结果为 boolean 值，

引用所指向的对象和类名类型是否一致（对象是否属于类名类型）
类型的转换：转换编译时类型
Sub su= (Sub) s;
子类型的引用向父类型转换时，不需要强转
父类型的引用向子类型转换时，需要强转
Animal a=new Cat();
Dog d=(Dog)a;   ／／ 类型转换异常
引用 instanceof 类名 -----> boolean
引用所指向的对象和类名所代表的类型是否一致

a instanceof Animal -----> true   a instanceof Cat----------> true
Employee e=new Manager();
e instanceof Employee ------>true
e instanceof Manager------> true


属性没有多态，属性只看编译时类型


编写程序的顺序：
class 类名｛
private 属性（有什么）
无参的构造方法（public 类名（）｛｝）
有参的构造方法（作用：给属性赋值）
set 和 get（设置和获得属性）
业务方法（做什么）
｝

a instanceof Dog----------->false



一，关键字：static
static 变量：如：static int index=2;
类的所有对象共同拥有的一个属性；可以用类名直接访问，又称为类变量，
类的所有对象共同拥有的一个变量；类第一次被加载时会初始化静态变量
（也就是会先执行 static 修饰的变量）；
跟类创建了多少对象无关；任何对象对静态变量做的修改，其他对象看到的是修改后的值。
可以用作计数器，记录类创建对象的个数 ， static 变量在类加载的时候只会被初始化一次，
static 方法：如：public static void teach(){}
可以用类名直接去调用，不需要对象所以不能直接访问（在没有对象的情况下）实例变量，
在静态方法里不能出现 this 和 super，类的所有对象共同拥有的一个方法；跟类创建了多少对象无关。
在继承里，父类的静态方法只能被子类的静态方法覆盖，且覆盖以后没有多态
（访问的是父类的静态方法）；
static 初始化块：如：class Teacher(){
static int index=4;
static{     //static 初始化块
.........
}
}
静态初始华块：用 static 修饰类里面的一个独立的代码块，类第一次被 JVM 加载的时候执行，只被执行一次。
类加载：JVM 在第一次使用一个类时，会到 classpath 所指定的路径去找这个类所对应的字节码文件，
并读进 JVM 保存起来，这个过程称之为类加载，一个线程一个 jvm。



批注 [U9]: 静态变量和实例
变量的区别？
static i = 10; //常量
class A a; a.i =10;//可变



二，final



（最后的，最终的）final 用于声明属性，方法和类，分别表示属性不可变，方法不可覆盖，类不可继承

final 类：如：final class Animal{}
表示该类不能被继承，意味着不能改变里面的代码；
对虚拟机的正常运行有重要作用的类通常用 final 修饰，如：String,System,Math ...等类

final 方法：如：public final void sleep(){}

该方法不能被覆盖（修改），但能被子类访问。



final 变量：如：final (static) int index=4;
该变量是常量能被继承（访问）；
final 修饰的变量就是常量，通常和 static 一起连用，来声明常量；
final 修饰引用类型数据，指的是引用（地址）不能变，但引用里的数据不受限制。
final 修饰的变量，只要在初始化的过程中就可以赋值。


9 








实例变量：声明的同时或构造方法里赋值；
静态变量：声明的同时或在静态代码块里赋值；


三，abstract
abstract 类：如：abstract class Animal{}
抽象类，不能创建对象(如一些父类)，但是可以声明一个抽象类型的引用
（可以声明父类类型子类对象，编译时利用多态调用抽象方法）。
含有抽象方法的类一定是抽象类，但抽象类并不一定要有抽象方法；
抽象类一般是用来被继承的；子类继承自抽象类，就要实现里面的抽象方法，
如果不想让子类也是抽象类的话，必须实现父类里面所有的抽象方法。
抽象类有构造方法，有父类，也遵循单继承的规律。


abstract 方法：如：public abstract void sleep();
抽象方法，只有方法名的定义，没有实现体（只定义了能做什么，没定义怎么做），不能被调用，
用于被子类的方法覆盖或重新实现。只能放在抽象类中。
好处：允许方法的定义和实现分开。

public protected default private static final

abstract

可以： public static
private static
public final
public static final
不可以：abstract final void eat();
private abstract void eat();
static abstract void eat();
abstract 不能和 final,private,static 连用。


四，interface：是抽象类的变体，。在接口中，所有方法都是抽象的。如：interface M{
int num=3;
void eat();
}
理解为接口是一个特殊的抽象类，所以接口不能创建对象，且接口没有构造方法，
但可以声明一个接口类型的引用（m 是接口类型实现类对象，如：M m=new N();）
接口存在的意义是被子类实现，如果不想让子类也抽象，
就要实现接口里面所有的抽象方法，实现过程中注意访问权限；


用 implements 关键字实现接口，如：class N implements M{
public void eat(){...}
}
接口里面的常量默认都是 public static final 的；
接口里面的方法默认都是 public abstract 的。



接口本身支持多继承，继承了父接口里功能的定义，如，interface A extends B,C,D{}
类可以同时继承一个父类和实现接口（或多个接口）。



//A，B，C，D 都是接口；

如：class AA extends BB implements CC,DD,EE{}//AA，BB

是类，CC，DD，EE 是接口；

作用：1，用接口去实现多继承，接口是对类的共性进行再次抽象，抽象出类的次要类型。
如：蜘蛛侠，拥有人和蜘蛛的属性，但主要类型是人，次要类型（接口）是蜘蛛，
因为接口是次要类型，所以在类关系里不占一个节点，不会破坏类层次关系的树状结构，
2，标准（保证弱耦合）：一个接口就是一个标准（里面的属性不能改变，只定义了功能，
但没有被实现）， 接口将标准的制定者，标准的实现者以及标准的使用者分离开，
降低实现者和使用者的耦合。接口是 java 里一种重要的降低耦合的工具；
接口可以屏蔽不同实现类的差异，
当底层的实现类更换后，不会对上层的使用者产生影响，体现在参数和返回值。


写程序时，应该先写实现者再写使用者，如：Bank.java 是实现者，View.java 是使用者，
但是有了接口之后，就可以用接口回调的功能；
接口回调：先定义接口，然后写使用者和实现者的顺序随便（一般是先写使用者，
后写实现者）；利用参数把实现者传给使用者（即：实现者是使用者的属性），
使用者利用接口调用实现者相应的功能。
**接口和抽象类的区别 1 一个类可以 implements 多个接口，而只能 extends 一个抽象类
2，一个抽象类可以实现部分的方法，而接口都是抽象的方法和属性


Object 是 Java 里所有类的直接或间接父类，Object 类里面的所有功能是所有 java 类共有的
1，JVM 调用垃圾回收器回收不用的内存（没有引用指向的对象）前运行 finalize()，给 JVM 用的方法。
程序显示的通知 JVM 回收没用的内存（但不一定马上就回收）：System.gc();或 Runtime.getRuntime().gc();


2，toString()返回对象的字符串表现形式，打印对象时，虚拟机会自动调用 toString 获取对象的字符串表现格式，
如：System.out.println(str.toString());＝＝System.out.println(str);
如果本类不提供（覆盖）toString()，那么使用的是 Object 类里的相应方法，打印的就是地址。
如：public String toString(){
return ".....";
}


10 








3，基本类型时“==“判断变量本身的值是否相等；引用类型时，判断的是地址是否相等。
equals 判断的是对象内容是否相等。对于自己创建的类，应该覆盖 Object 类的 equals()方法;
否则使用的是 Object 类里的 equals()方法，比的是地址。


覆盖方法如下：
/*****************************************************
public boolean equals(Object o){
if(o==null) return false;
if(o==this) return true;
if(!(o.getClass()==this.getClass())) return false;
final Student s=(Student)o;
return this.name.equals(s.name) && this.age==s.age ; //比较原则；
}
******************************************************/
覆盖 euqals()方法时遵循的原则：
自反性：a.quals(a);    //true
对称性：a.equals(b);＜==＞ b.equals(a);//true
传递性：a.equals(b);//true    b.equals(c); //true
－－－＞则：a.equals(c); //为 true



封装类（Wrapper class）：
OverLoading 时，基本类型时采用向上匹配原则，
如果没有基本类型的话就向包装类转换，如果还没有就让这个基本类型在包装类里也采用向上匹配原则；


基本类型－转换到－－＞包装类



批注 [U10]: Java 提供两种
不同的类型：引用类型和原始
类型（或内置类型）。Int 是

boolean－－－－－＞Boolean
int－－－－－－－－＞Integer
int－－－－－－－－＞Ddouble
double－－－－－－＞Double
...... －－－－－－－＞



//Integer 是引用类型，
//合法，    但 Integer－－－－－－＞Double


......



非法

java 的原始数据类型，
Integer
是 java 为 int 提供的封装

任何类型－－－－－＞Object
基本数据类型 int 可以向 double 自动扩展，但是包装类型之间不能自动的相互转换，
基本类型数据－－－＞包装类型
int i=3;
Integer it=new Integer(i);   //手动转换；基本类型向包装类型转换。
int <－－－－> Integer <－－－－> String
转换时 String 类型必须为全数字字符串。如："2515" 不能为："abc265","aec"...等
String str=”123”; int it=Integer,parseInt(str);把字符串转换成数字。String str2=it+“”；把数字转化成字符串


＝＝内部类＝＝＝＝＝＝＝＝＝＝＝＝
定义在其他代码块（类体或者方法体）里的类称为内部类；
编译后每一个内部类都会有自己的独立的字节码文件，
文件名：Outer$Inner.class－－＞内部类也可以有父类和实现接口。也可以有抽象方法。


根本位置和修饰符的不同分为四种：

类。Java 为每个原始类型提
供了封装类

1，member inner class

成员内部类，当实例方法或变量一样理解。

1）定义的位置：类以内，方法之外，没有静态修饰符（static）。
2）本身能定义的属性和方法：只能定义非静态的属性和方法。
3）能直接访问的什么：能访问外部类的所有静态和非静态的属性或方法。
4）怎么创建对象：在外部类内的方法内：Outer.Inner inner=new Outer().new Inner();
在外部类外的类的方法内：Outer.Inner inner=new Outer().new Inner();或
在 Outer 类里提供一个 getInner()方法,返回内部类的对象，这样在外部类外的类的方法内也可以用该成员内部类。


2，static inner class 静态内部类（嵌套内部类），当静态方法或变量一样理解。
static 只能修饰内部类，不能修饰外部类。
1）定义的位置：类以内，方法之外，有静态修饰符（static）。一般写在外部类的属性下面。
2）本身能定义的属性和方法：可以定义静态和非静态的属性或方法。
3）能直接访问的什么：只能访问外部类的静态属性和方法。
4）怎么创建对象：在外部类内的方法里： Outer.Inner inner=new Outer.Inner();
在外部类外的类方法里： Outer.Inner inner=new Outer.Inner();

3，local inner class

局部内部类

当局部变量一样理解。

1）定义的位置：方法里面的类，前面不能用 public 或 static 修饰。
2）本身能定义的属性和方法：只能定义非静态的属性和方法。
3）能直接访问的什么：能访问方法内用 final 修饰的局部变量（不能与该类内的变量名相同）。
能访问外部类的所有静态和非静态的属性或方法。
4）怎么创建对象：只能在方法内创建对象，如：Inner inner=new Inner(); 对象的作用范围只在方法内。

4，annonymous inner class

匿名内部类

如： Teacher tc=new Teacher(){

1）没有名字的类，没有构造方法。是一个特殊的局部内部类，         public void teach(){...}
可以实现一个接口， 或者一个类，                       }
生命周期里只能产生一个对象(tc)，也就是说只能被一个对象（tc）调用，
2）除了没有名字外，看匿名内部类所在的位置，他的定义和访问将和成员内部类、静态内部类、局部内部类一样。
一般像局部内部类的定义和访问比较多。
11 








3）当试图创建接口或者抽象类对象的时候，用匿名内部类。
表示类体的{...}紧跟在抽象实例（接口）之后，表示实现该抽象实例（接口）。
调用匿名内部类的方法只能用写类时创建的那个对象（tc）。
作用：1，不破坏访问权限的情况下，内部类可以使用外部类的私有成员变量和方法。
2，将接口公开，将实现类（实现公开的接口）作成内部类隐藏起来，强制要求使用者使用接口，强制降低偶合度。
3，Java 通过接口和内部类两种机制来实现多继承。在类内部可以建立本类的实例，然后调用本类内的其他方法。
Exception(异常)：运行时的概念。
1，Throwable：运行时可能碰到的任何问题的总称；
1）Error：指非常严重的错误，系统不要求程序员处理，也处理不了。如：硬件坏了.....等。
2）Exception：从代码的角度是程序员可以处理的问题；
UncheckedException(RuntimeException 的子类) （未检查异常）如果是 RuntimeException（或子类）就是为检查异常，其他就是已检查
异常
程序员小心谨慎完全可以避免的异常，系统不要求程序员处理（可以不管,运行会提示错误），
如：3/0     数组下标越界。
CheckedExcepiton （已检查异常）
系统要求必须处理异常。
2，异常处理：异常是相对于方法来说的。
1）声明抛出异常（消极的处理）
throws（抛弃）：写在方法名的定义上，后面跟要抛弃的异常类型。
如：public void m1() throws Exception{.}
异常产生时，责任可能并不在当前方法，向外抛弃（把异常抛弃，留给调用者处理）可以让异常找到一个最佳的位置处理
抛弃过程中可以对异常类型进行扩展，但是不能缩小。
throw（抛出）：一般出现在方法实现里，用来抛出异常对象（或者是产生异常），
如：throw new FileNotFoundException();
当代码出现异常时，代码不会向下执行，JVM 会将异常封装成相应的异常类的对象，
然后向外抛出。之后这个方法里剩下的代码就不会再执行了。
对于一个方法的返回值：
1）正常运行时，要求方法必须返回定义的类型的值。
2）如果运行不正常（出现异常），方法返回的是异常对象
方法覆盖：名相同，参数相同，返回类型相同，访问权限不能更小，子类抛弃的异常不能比父类更多。
2）try....catch（积极的处理）：
一个 try 语句后可以跟多个 catch 语句；catch 时异常子类放上面，异常父类放下面。
如果没有父子关系，先后无所谓；
－－－方法－－－( ){
try{
//可能会出现异常的代码
xxxxxxxxxx; （1）
xxxxxxxxxx; （2）
}catch(Exception1 e1){
//当 try 代码块出现异常时,执行 catch 代码块。
xxxxxxxxx; （3）
}catch(Exception2 e2){
xxxxxxxxx; （4）
}finally{
//不管有没有异常出现都要执行的代码。
xxxxxxxxx; （5）
}
xxxxxxxxx; （6）
}
1）如果（1），（2）没产生异常，（2）执行后直接执行（5），然后执行（6）。
2）如果（1）产生异常，（2）不会被执行，直接跑出 try{..},匹配 catch，和 catch 里定义的类型一致，
执行 catch 完了后，直接跳到（5）执行，最后再执行（6）,如果异常类型都不一致，将导至语法问题。
3）自定义异常类型（业务异常）：
如：class MyException extends Exception{
public MyException(String str);
super(str);
}
Exception 异常总结：
1、如果程序用了 System.exit(0);则不会执行 finally 里的程序
2、在程序 return 前执行 finally 里的程序
3、Java 中异常分为两类：
1) checked Exception
处理方式一、继续抛出，消极做法，直到抛出到 JVM
处理方式二、用 try..catch
2) unchecked Exception (runtime exception)
throws ArithmeticException,IOException 应该是出现这两种异常就向上抛吧。
什么情况下一个方法抛出几个异常？一般来说应该是会抛出几种异常，然后在一级调用这个方法时处理一下。
如果没有特殊需要的话要把可能出现的异常都截获并处理。
try{
method();
}catch(exception1 e1){
do something;
12 








}catch(exception2 e2){
do something;
}……
e1 的范围小于 e2.


12、final, finally, finalize 的区别。
final 用于声明属性，方法和类，分别表示属性不可变，方法不可覆盖，类不可继承。
finally 是异常处理语句结构的一部分，表示总是执行。
finalize 是Object 类的一个方法，在垃圾收集器执行的时候会调用被回收对象的此方法，可以覆盖
此方法提供垃圾收集时的其他资源回收，例如关闭文件等。