一、继承
“不要去重新发明车轮,而是去改善它。”继承,面向对象编程的三大特性之一,让我们更加容易实现类的扩展,实现代码重用。
1. 继承的两个主要作用
1.代码复用,更容易实现类的扩展。
2.方便建模。
2.继承的实现
这是现实世界中的继承。哺乳动物继承了动物等等特性,而狗又继承了哺乳动物的特性。
Java中,我们用extends实现类的继承。
比如
package Java;
public class TestExtends {
public static void main(String[] args) {
Student stu = new Student("cqk", 1, "Java");
System.out.println(stu.name);//可以使用Person中的name属性
stu.rest();//可以调用Person中的rest方法
System.out.println("stu是Student类吗:" + (stu instanceof Student));
System.out.println("stu是Person类吗:" + (stu instanceof Person));
System.out.println("stu是Object类吗:" + (stu instanceof Object));
}
}
class Person {//没有跟extends的话编译器自动加:extends Object
//类Person中定义了两个属性和一个方法。
String name;
int height;
public void rest(){
System.out.println("我要休息!");
}
public Person(String name, int height) {
this.name = name;
this.height = height;
}
}
class Student extends Person{//Student会继承Person的属性和方法
String major;//Student中新定义的属性
public void study(){//Student中新定义的方法
System.out.println("我在学习!");
}
public Student(String name, int height, String major) {
super(name, height);
this.major = major;
}
}
我们定义一个Person类,然后定义一个Student类,并用语句
class Student extends Person
使Student继承Person的属性和方法,此时Student是子类,Person是父类, 子类是父类的扩展。除此之外Student中我们定义自己的major属性和study方法。
于是可以看到,在main方法中,Student类对象stu具有name、rest等Person中定义的属性和方法,可以进行调用,说明子类会继承父类的属性和方法。
3. Object类
如上代码所示,Person类未加extends,那么是否意味着Person类没有父类呢?其实不然,对于没有extends的类,编译器会在其后自动加extends Object。也就是说,没有加extends的类的父类都是Object类。Object类是java.lang包中的一个类(Ctrl + 单击可以查看)。(不展开叙述)
4. instanceof运算符
instanceof运算符是二元运算符,左边是对象,右边是类,当对象是右边类或其子类所创建的对象时,返回true,否则返回false。
如上代码,main方法中,最后三个打印的语句打印了stu是否是Student、Person、Object类的(即,是否是它们及其子类所创建),其中instanceof语句的结果均为true,说明stu是它们及其子类所创建的。
5. 继承的其他使用要点
1. 父类也称作超类、基类;子类也被称作派生类等。
2. Java中类只有单继承,没有像c++那样的多继承,多继承会引起混乱,使得继承链过于复杂,系统难以维护。
3. 子类继承父类,可以得到父类的全部属性和方法(除了父类的构造方法),但不见得可以直接访问(比如,父类私有的属性和方法)(在封装中在深入研究)
6. 方法的重写override
不同的人群,休息的方式有区别,那么Person的不同子类想要有不同的rest方法,怎样实现?我们可以用override。
子类重写父类的方法,可以用自身行为替换父类行为。重写是实现多态的必要条件。
用具体代码说明。
package Java;
public class TestExtends {
public static void main(String[] args) {
Student stu = new Student("cqk", 1, "Java");
Worker w = new Worker("w", 1);
stu.rest();//输出"苦逼学生只能趴在书桌上休息!"
w.rest();//输出"苦逼上班族也只能趴在工位上休息啊!!"
}
}
class Person extends Object{
String name;
int height;
public void rest(){
System.out.println("我要休息!");
}
public Person(String name, int height) {
this.name = name;
this.height = height;
}
}
class Student extends Person{
String major;
public void study(){
System.out.println("我在学习!");
}
@Override
public void rest() {//重写Student的rest方法
System.out.println("苦逼学生只能趴在书桌上休息!");
}
public Student(String name, int height, String major) {
super(name, height);
this.major = major;
}
}
class Worker extends Person {//定义了一个新的类worker,是Person的子类
public Worker(String name, int height) {
super(name, height);
}
@Override
public void rest() {//重写Worker的rest方法
System.out.println("苦逼上班族也只能趴在工位上休息啊!!");
}
}
首先我们重写Student的rest,使得Student有自己休息的方式,即趴在书桌上。我们又定义了一个新类Worker,继承了Person,其中重写rest,让上班族趴在工位上休息。
main方法中,分别调用rest,可以分别输出他们对应的rest方式,而不是输出Person中的“我要休息!”。这说明,子类中重写了的rest方法覆盖了父类的方法,使得调用的时候执行子类中重写的方法。但父类的方法依然存在,我们在之后讨论super的时候再详细展开吧。
方法重写需要符合下面的三个要点:
1. “==” :方法名、形参列表相同。
2. “≤”:返回值类型和声明异常类型,子类小于等于父类。
3. “≥”:访问权限,子类大于等于父类。
字面意思,限于篇幅,不展开详述。
7. 继承和组合
我们考虑怎样不用继承来实现代码复用,那我们就用组合。组合核心是:“将父类的对象作为子类的属性”。下面我们就用组合实现之前继承的代码。
package Java;
import java.sql.PreparedStatement;
public class TestExtends {
public static void main(String[] args) {
Student stu = new Student();
stu.p.name = "cqk";
stu.study();//输出"cqk在学习!"
}
}
class Person extends Object{
String name;
int height;
public void rest(){
System.out.println("我要休息!");
}
}
class Student {//不用extends
Person p = new Person();//new一个Person的对象作为我Student的属性
String major;
public void study(){
System.out.println(this.p.name + "在学习!");//调用name时,需要这样输入this.p.name
}
}
这次我们定义Student时不用extends,而是用了组合,new了一个Person的对象p作为我Student的一个属性,这样我依然可以调用Person中的属性和方法。如Student的study方法中,我用this.p.name调用了对象p的属性name。并且我在main方中可以一样,直接调用stu.p.name和用了study方法调用了stu.p.name。于是我们就不用继承而实现了代码复用。
但有人会因此认为组合优于继承,我们都应该用组合而不是用继承。诚然,组合更灵活,我可以在一个类中定义多个不同类的对象,从而拥有多个父类。但是别忘了,继承不只代码复用这一个作用,它还能更方便建模,即构建类之间的逻辑关系,就像上面第一张图“现实世界中的继承”那样。因此,我们一般对于构建逻辑关系时,“is-a”关系建议使用继承,“has-a”关系建议使用组合,如上面的Person和Student的关系就属于“is-a”关系,我们用继承会好些;而对于像“手机”和“芯片”这样的关系我们认为是“has-a”关系,可以用组合。
二、接口
接口是更加特殊的抽象类,它是一组规范,规定了其实现类所要实现的功能。
1. 声明格式
[访问修饰符] interface 接口名 [extends 父接口1, 父接口2...]{
常量定义;
方法定义;
}
2. 接口的实现
class 类名 implements 接口1, 接口2...{}
3. 几点注意
其中访问修饰符只能是 public 或默认。
extends之后可以接多个父接口,即接口可以多继承。
接口中的属性只能是常量,总是:public static final修饰。不写也是。
接口中的方法只能是:public abstract。省略的话,也是public abstract。
JDK1.8(不含8)之前,接口中只能包含静态常量、抽象方法,不能有普通属性、构造方法、普通方法;JDK1.8 (含8)后,接口中包含普通的静态方法、默认方法。
子类通过 implements 来实现接口中的规范。
接口不能创建实例,但是可用于声明引用变量类型。
一个类实现了接口,必须实现接口中所有的方法,并且这些方法只能是public的。
三、多态
对于同一个动作,不同人的做法不一样,比如吃饭,中国人吃饭用筷子,西方人吃饭用刀叉。Java中,我们用一种叫多态的方式,来实现同一个方法调用,不同的对象行为完全不同。
1. 多态的要点
1. 多态是方法的多态,不是属性的多态(多态与属性无关)。
2. 多态的存在要有3个必要条件:继承,方法重写,父类引用指向子类对象。
3. 父类引用指向子类对象后,用该父类引用调用子类重写的方法,此时多态就出现了。
四、异常类
工作中程序可能遇到各种不同的意外问题,异常机制就是用于对这些情况进行合理的处理和解决,其本质为一个当程序出现异常,程序安全的退出、处理完后继续执行的机制。
1. 异常类的分类
Exception 异常类是 Throwable类的子类。Throwable类的另一个子类是Error类。异常类分为 CheckedException 和 RuntimeException 两部分。
1. RuntimeException 运行时异常
1) ArithmeticException :试图除以0。
解决:添加变量不等于0的判断。
2) NullPointException 空指针异常
解决:添加变量不等于null的判断。
3) ClassCastException 类型转化异常。
将Dog类对象转换为Cat类变量。
解决:添加变量是否 instanceof 该类的判断。
4) ArrayIndexOutOfBoundsException 数组越界异常
解决:添加变量在 [0, arr.length()) 的判断。
5) NumberFormatException 数字格式化异常
String str = "1234abcd";
System.out.println(Integer.parseInt(str));
此时出现数字格式化异常。
解决:
String str = "1234abcd";
Pattern p = Pattern.compile("^\\d+$");
Matcher m = p.matcher(str);
if(m.matches()){
System.out.println(
Integer.parseInt(str);
);
}
2. CheckedException 已检查异常
CheckedException在编译时处理,否则无法通过编译。
两种处理方式:
1. “try/catch” 捕获异常机制
2. “throw” 声明异常
2. 捕获异常机制
我们用 “try/catch” 语句实现
如上图所示,程序从try部分开始运行,若遇到异常语句,则直接跳至catch部分的相应语句执行。若未遇到异常语句,不执行catch部分语句。最后一定执行finally部分的语句。
几个注意点:
1. 当异常处理的代码执行结束以后,不会回到 try 语句去执行尚未执行的代码。
2. 如果异常类之间有继承关系,先捕获子类异常再捕获父类异常。
3. 通常在finally中关闭已打开的资源,比如:关闭文件流、释放数据库连接等。
3. 声明式异常处理
1. CheckedException 产生时,不一定立刻处理它,可以把异常throws,由调用者处理
2. 一个方法抛出多个已检查异常,就必须在方法的首部列出所有的异常。