一、final关键字
1、final修饰的类无法继承。
2、final修饰的方法无法覆盖。
3、final修饰的变量只能赋一次值。
4、final修饰的引用一旦指向某个对象,则不能再重新指向其它对象,但该引用指向的对象内部的数据是可以修改的。
5、final修饰的实例变量必须手动初始化,不能采用系统默认值。
6、final修饰的实例变量一般和static联合使用,称为常量。
public static final double PI = 3.1415926;
二、抽象类和接口
1、抽象类
1)抽象类的基础语法
①抽象类怎么定义?在class前添加abstract关键字就行了。
②抽象类是无法实例化的,无法创建对象的,所以抽象类是用来被子类继承的。
③final和abstract不能联合使用,这两个关键字是对立的。
④抽象类的子类可以是抽象类。也可以是非抽象类。
⑤抽象类虽然无法实例化,但是抽象类有构造方法,这个构造方法是供子类使用的。
⑥抽象类中不一定有抽象方法,抽象方法必须出现在抽象类中。
⑦抽象方法怎么定义?public abstract void doSome();
⑧☆☆☆☆☆ 一个非抽象的类,继承抽象类,必须将抽象类中的抽象方法进行覆盖/重写/实现。
到目前为止,只是学习了抽象类的基础语法,一个类到底声明为抽象还是非抽象,这个以后慢慢来吧。写代码多的时候,自然就理解了。
2)面试题(判断题)
java语言中凡是没有方法体的方法都是抽象方法。
答案:×
解析:Object类中就有很多方法都没有方法体,都是以“;”结尾的,但他们都不是抽象方法,例如:
public native int hashCode(); 这个方法底层调用了C++写的动态链接库程序。前面修饰符列表中没有abstract,有一个native,表示调用JVM本地程序。
2、接口
1)接口的基础语法
①接口是一种“引用数据类型”。
②接口是完全抽象的。
③接口怎么定义:[修饰符列表] interface 接口名{}
④接口支持多继承(一个接口可继承多个接口)。
⑤接口中只有常量+抽象方法。
⑥接口中所有的元素都是public修饰的
⑦接口中抽象方法的public abstract可以省略。
⑧接口中常量的public static final可以省略。
⑨接口中方法不能有方法体。
⑩一个非抽象的类,实现接口的时候,必须将接口中所有方法加以实现。
⑩①一个类可以实现多个接口。
⑩②extends和implements可以共存,extends在前,implements在后。
⑩③使用接口,写代码的时候,可以使用多态(父类型引用指向子类型对象)。
2)接口在开发中的作用
注意:接口在开发中的作用,类似于多态在开发中的作用。
多态:面向抽象编程,不要面向具体编程。降低程序的耦合度。提高程序的扩展力。
/*
public class Master{
public void feed(Dog d){}
public void feed(Cat c){}
//假设又要养其它的宠物,那么这个时候需要再加1个方法。(需要修改代码了)
//这样扩展力太差了,违背了OCP原则(对扩展开放,对修改关闭。)
}
*/
public class Master{
public void feed(Animal a){
// 面向Animal父类编程,父类是比子类更抽象的。
//所以我们叫做面向抽象编程,不要面向具体编程。
//这样程序的扩展力就强。
}
}
面向抽象编程这句话以后可以修改为:面向接口编程。有了接口就有了可插拔。可插拔表示扩展力很强。不是焊接死的。
主板和内存条之间有插槽,这个插槽就是接口,内存条坏了,可以重新买一个换下来。这叫做高扩展性。(低耦合度。)
接口的作用总结一句话:三个字“解耦合”
面向接口编程,可以降低程序的耦合度,提高程序的扩展力。符合OCP开发原则。
接口的使用离不开多态机制。(接口+多态才可以达到降低耦合度。)
接口可以解耦合,解开的是谁和谁的耦合:
任何一个接口都有调用者和实现者。接口可以将调用者和实现者解耦合。调用者面向接口调用。实现者面向接口编写实现。以后进行大项目的开发,一般都是将项目分离成一个模块一个模块的,模块和模块之间采用接口衔接。降低耦合度。
3、类型和类型之间的关系:
is a(继承)、has a(关联)、like a(实现)
1)is a:
Cat is a Animal(猫是一个动物)。凡是能够满足is a的表示“继承关系”
A extends B
2)has a:
I has a Pen(我有一支笔),凡是能够满足has a关系的表示“关联关系”,关联关系通常以“属性”的形式存在。
A{
B b;
}
3)like a:
Cooker like a FoodMenu(厨师像一个菜单一样),凡是能够满足like a关系的表示“实现关系”,实现关系通常是:类实现接口。
A implements B
4、抽象类和接口的区别
在这里我们只说一下抽象类和接口在语法上的区别。至于以后抽象类和接口应该怎么进行选择,通过后面的项目去体会/学习。
1)抽象类是半抽象的,接口是完全抽象的。
2)抽象类中有构造方法,接口中没有构造方法。
3)接口和接口之间支持多继承,类和类之间只能单继承。
4)一个类可以同时实现多个接口, 一个类只能继承一个抽象类(单继承)。
5)接口中只允许出现常量和抽象方法。
这里先透露一个信息:以后接口使用的比抽象类多。一般抽象类使用的还是少。接口一般都是对“行为”的抽象。
三、package和import(不用测,知道就行)
1、package
第一:package出现在java源文件第一行。
第二:带有包名怎么编译?javac -d . xxx.java
第三:怎么运行?java 完整类名
补充:以后说类名的时候,如果带着包名描述,表示完整类名。如果没有带包,描述的话,表示简类名。
java.util.Scanner 完整类名。
Scanner 简类名
2、import
import什么时候不需要?
java.lang不需要,同包下不需要。,其它一律都需要。
语法格式:
import 完整类名;
import 包名.*;
import java.util.Scanner; // 完整类名。
// 同学的疑问:这样是不是效率比较低。
// 这个效率不低,因为编译器在编译的时候,会自动把*变成具体的类名。
import java.util.*;
// 想省懒劲你不能太省了。
import java.*; 这是不允许的,因为在java语言中规定,这里的*只代表某些类的名字。
四、访问控制权限
1、访问控制权限都有哪四个?
private 私有
public 公开
protected 受保护
默认
2、以上的4个访问控制权限:控制的范围是什么?
private 表示私有的,只能在本类中访问
public 表示公开的,在任何位置都可以访问
“默认”表示只能在本类,以及同包下访问。
protected表示只能在本类、同包、子类中访问。
访问控制修饰符 | 本类 | 同包 | 子类 | 任意位置 |
public | 可以 | 可以 | 可以 | 可以 |
protected | 可以 | 可以 | 可以 | 不行 |
默认 | 可以 | 可以 | 不行 | 不行 |
private | 可以 | 不行 | 不行 | 不行 |
这个不要死记硬背,自己下去之后编写代码自己测试。
范围从大到小排序:public > protected > 默认 > private
3、访问控制权限修饰符可以修饰什么?
属性(4个都能用)
方法(4个都能用)
类(public和默认能用,其它不行。)
接口(public和默认能用,其它不行。)
.....
五、JDK类库的根类:Object
这个老祖宗类中的方法我们需要先研究一下,因为这些方法都是所有子类通用的。任何一个类默认继承Object。就算没有直接继承,最终也会间接继承。
1、Object类当中常用的方法
我们去哪里找这些方法呢?
第一种方法:去源代码当中。(但是这种方式比较麻烦,源代码也比较难)
第二种方法:去查阅java的类库的帮助文档。
什么是API?
应用程序编程接口。(Application Program Interface)
整个JDK的类库就是一个javase的API。
每一个API都会配置一套API帮助文档。
SUN公司提前写好的这套类库就是API。(一般每一份API都对应一份API帮助文档。)
目前为止我们只需要知道这几个方法即可:
protected Object clone() // 负责对象克隆的。
int hashCode() // 获取对象哈希值的一个方法。
boolean equals(Object obj) // 判断两个对象是否相等
String toString() // 将对象转换成字符串形式
protected void finalize() // 垃圾回收器负责调用的方法
2、toString()方法
以后所有类的toString()方法是需要重写的。重写规则:越简单越明了就好。
System.out.println(引用); 这里会自动调用“引用”的toString()方法。
String类是SUN写的,toString方法已经重写了。
3、equals()方法
以后所有类的equals方法也需要重写,因为Object中的equals方法比较的是两个对象的内存地址,我们应该比较内容,所以需要重写。
重写规则:自己定,主要看是什么和什么相等时表示两个对象相等。
基本数据类型比较:用==
对象和对象比较:调用equals方法
String类是SUN编写的,所以String类的equals方法重写了。
以后判断两个字符串是否相等,最好不要使用==,要调用字符串对象的equals方法。
注意:重写equals方法的时候要彻底。
4、finalize()方法
这个方法是protected修饰的,在Object类中这个方法的源代码是?
protected void finalize() throws Throwable { }
六、匿名内部类
1、什么是内部类?
在类的内部又定义了一个新的类,被称为内部类。
2、内部类的分类:
静态内部类:类似于静态变量
实例内部类:类似于实例变量
局部内部类:类似于局部变量
3、一些注意事项
1)使用内部类编写的代码,可读性很差。能不用尽量不用。
2)匿名内部类是局部内部类的一种。因为这个类没有名字而得名,叫做匿名内部类。
3)学习匿名内部类主要是让大家以后在阅读别人代码的时候,能够理解。并不代表以后都要这样写。因为匿名内部类有两个缺点:
缺点1:太复杂,太乱,可读性差。
缺点2:类没有名字,以后想重复使用,不能用。
4)不理解算了,你只要记住这种写法就行。
class Test01{
// 静态变量
static String country;
// 该类在类的内部,所以称为内部类
// 由于前面有static,所以称为“静态内部类”
static class Inner1{
}
// 实例变量
int age;
// 该类在类的内部,所以称为内部类
// 没有static叫做实例内部类。
class Inner2{
}
// 方法
public void doSome(){
// 局部变量
int i = 100;
// 该类在类的内部,所以称为内部类
// 局部内部类。
class Inner3{
}
}
public void doOther(){
// doSome()方法中的局部内部类Inner3,在doOther()中不能用。
}
// main方法,入口
public static void main(String[] args){
// 调用MyMath中的mySum方法。
MyMath mm = new MyMath();
/*
Compute c = new ComputeImpl();
mm.mySum(c, 100, 200);
*/
//合并(这样写代码,表示这个类名是有的。类名是:ComputeImpl)
//mm.mySum(new ComputeImpl(), 100, 200);
// 使用匿名内部类,表示这个ComputeImpl这个类没名字了。
// 这里表面看上去好像是接口可以直接new了,实际上并不是接口可以new了。
// 后面的{} 代表了对接口的实现。
// 不建议使用匿名内部类,为什么?
// 因为一个类没有名字,没有办法重复使用。另外代码太乱,可读性太差。
mm.mySum(new Compute(){
public int sum(int a, int b){
return a + b;
}
}, 200, 300);
}
}
// 负责计算的接口
interface Compute{
// 抽象方法
int sum(int a, int b);
}
// 你自动会在这里编写一个Compute接口的实现类
/*
class ComputeImpl implements Compute{
// 对方法的实现
public int sum(int a, int b){
return a + b;
}
}
*/
// 数学类
class MyMath{
// 数学求和方法
public void mySum(Compute c, int x, int y){
int retValue = c.sum(x, y);
System.out.println(x + "+" + y + "=" + retValue);
}
}