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 修饰的变量,只要在初始化的过程中就可以赋值。











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


三,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 类的一个方法,在垃圾收集器执行的时候会调用被回收对象的此方法,可以覆盖
此方法提供垃圾收集时的其他资源回收,例如关闭文件等。

评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值