一:继承(extends)
1.如何表达这个关系呢?
通过extends关键字可以实现类与类的继承
格式:
class 子类名 extends 父类名 {}
父类:基类,超类
子类:派生类
例: 学生类:
成员变量:name,age
构造方法:无参,带参
成员方法:getXxx()/setXxx(),eat(),sleep()
老师类:
成员变量:name,age
构造方法:无参,带参
首先定义个 -------人类:
成员变量:name,age
构造方法:无参,带参
成员方法:getXxx()/setXxx(),eat(),sleep()
学生类:老师类,都继承人类
优点: A:提高了代码的复用性
多个类相同的成员可以放到同一个类中
B:提高了代码的维护性
如果功能的代码需要修改,修改一处即可
1.必须存在继承关系
2.父类的方法满足不了你的需求,此时你就需要重写父类的方法,实现自己想要实现的功能
继承的特点:
A:Java只支持单继承,不支持多继承。一次只能继承一个父类
B:Java支持多层(重)继承(继承体系)。(父类还可以继承)
继承中类之间体现的是:”is a”的关系
3.类的组成:成员变量 构造方法 成员方法
继承间的成员变量关系:
A:名字不同,非常简单。
B:名字相同
首先在子类局部范围找
然后在子类成员范围找
最后在父类成员范围找(肯定不能访问到父类局部范围)
如果还是没有就报错。(不考虑父亲的父亲…)
就近原则。
需求:
请在show方法中输出4,3,2,1
class Fu {
public int num = 1;
}
class Zi extends Fu {
public int num2 = 2;
public int num = 3;
public void show() {
int num = 4;
int a=this.num;
int b = super.num;
System.out.print(num);
System.out.print(a);
System.out.print(num2);
System.out.print(b);
}
}
class ExtendsTest {
public static void main(String[] args) {
Zi z = new Zi();
z.show();
}
}
怎么去访问父亲的成员呢?
java就提供了一个关键字:super
super:
super代表父类存储空间的标识(可以理解为父类对象)
this和super的使用区别?
A:成员变量
this.成员变量 本类的成员变量
super.成员变量 父类的成员变量
B:成员方法
this.成员方法() 本类的成员方法
super.成员方法()父类的成员方法
4.继承间的成员方法关系:
A:方法名不同,非常简单
B:方法名相同
首先在子类中找
然后在父类中找
如果还是没有就报错。(不考虑父类的父类…)
1.7
继承间构造方法的关系:
子类中所有的构造方法默认都会访问父类中空参数的构造方法
因为子类会继承父类中的数据,可能还会使用父类的数据。
所以,子类初始化之前,一定要先完成父类数据的初始化。
每个子类的构造方法的第一行,有一条默认的语句:
super();
注意:仅仅是完成数据的初始化,创建对象目前必须用new申请空间。
假如父类没有无参构造方法,该怎么办呢?
A:调用父类的其他构造方法。带参构造。
怎么访问呢?
super(...)
注意:
super(…)或者this(….)必须出现在第一条语句上。
因为如果可以放后面的话,就会对父类的数据进程多次初始化。所以,只能放在第一条语句上。
无参构造最好自己给出。
二:final关键字
在实际开发的时候,有些方法的内容一旦写定后,就不允许被改动。
即时是子类,也不允许。那么该怎么解决这个问题呢?
java为了解决这样的问题就提供了一个关键字:final
final:
最终的意思。它可以修饰类,方法,变量。
特点:
修饰方法,方法不能被重写。
【重点】修饰类,类不能被继承。
修饰变量,变量的值不能再改动。其实这个时候变量已经变成了常量。
常量:
A:字面值常量
'a',12,"hello"
B:自定义常量
就是把变量用final修饰。
定义一个常量。
final 数据类型 变量名;
final int MAX_AGE = 20;
三:多态
多态:同一个对象,在不同时刻表现出来的不同状态。
多态的前提:
A:有继承关系
B:有方法重写(不是必要条件,但是只有有了方法重写多态才有意义)
C:有父类引用指向子类对象
Fu f = new Fu();
左边:Fu类型的引用
右边:Fu类型的对象
Zi z = new Zi();
Fu f = new Zi();父类引用指向子类对象
成员访问特点
A:成员变量
编译看左边,运行看左边
B:构造方法
子类构造默认访问父类的无参构造
C:成员方法(重点理解)
编译看左边,运行看右边
为什么变量和方法不一样呢?
方法重写。
D:静态成员方法
编译看左边,运行看左边
因为静态的内容是和类相关的,与对象无关。(静态-随着类的加载而加载,与创不创建无关)
练习:
看程序写结果(先判断有没有问题,如果没有,写出结果)
class Fu {
public void show() {
System.out.println("fu show");
}
}
class Zi extends Fu {
public void show() {
System.out.println("zi show");
}
public void method() {
System.out.println("zi method");
}
}
class DuoTaiTest {
public static void main(String[] args) {
Fu f = new Zi();
f.method(); //false
f.show(); //zi show
}
}
练习:(猫狗案例演示)
如何使用子类特有功能
A:创建子类对象
B:把父类引用转为子类对象
向上转型
从子到父
父类引用指向子类对象
向下转型
从父到子
父类引用转为子类对象
四:抽象类
4.1
抽象类特点:
A:抽象类和抽象方法必须用abstract关键字修饰
B:抽象类不一定有抽象方法,有抽象方法的类一定是抽象类
C:抽象类不能实例化
那么,如果实例化并使用呢?
按照多态的方式,由具体的子类实例化。其实这也是多态的一种,抽象类多态。
D:抽象类的子类
要么是抽象类
要么重写抽象类中的所有抽象方法
抽象类的作用:
强制要求子类必须要重写某些方法。
4.2
抽象类 -- 特点 -- 成员特点 -- 案例
类的组成:
成员变量:
构造方法:
成员方法:
抽象类的成员:
成员变量:可以是变量,也可以是常量。
构造方法:有构造方法
不能实例化,构造方法有什么用呢?
用于子类访问父类数据的初始化。
成员方法:既可以是抽象的,也可以是非抽象的。
五、多态:
具体类多态
class Fu {}
class Zi extends Fu {}
抽象类多态
abstract class Fu {}
class Zi extends Fu {}
接口多态
多态的前提:
继承
方法重写
因为抽象类中的方法是抽象方法。
父类引用指向子类对象
五:接口
认识接口:不是我们现实生活中的usb接口等等实物的接口,类实现接口代表着这个类自身功能的一种扩展,所以接口代表着一种扩展的能力
接口的特点:
A:定义接口要用关键字interface表示
格式:interface 接口名 {}
B:类实现接口用implements表示
格式:class 类名 implements 接口名 {}
C:接口不能实例化
那么,接口如何实例化呢?
按照多态的方式,由具体的子类实例化。其实这也是多态的一种,接口多态。
D:接口的实现类
要么是抽象类
要么重写接口中的所有抽象方法
多态的前提:
A:有继承或者实现关系
B:有方法重写
C:有父类引用或者父接口引用指向子类或者实现类对象
多态分类:
A:具体类多态
B:抽象类多态
C:接口多态
接口的成员特点:
A:成员变量
只能是常量。
默认修饰符:public static final
B:构造方法
没有构造方法
C:成员方法
只能是抽象方法。
默认修饰符:public abstract
类与类:
继承关系。只能单继承,可以多层(重)继承。
类与接口:
实现关系。可以单实现,也可以多实现。
还可以在继承一个类的同时实现多个接口。
接口与接口:
继承关系。可以单继承,也可以多继承。
接口和抽象类的关系最后分析:
抽象类和接口的区别
A:成员区别
抽象类:
成员变量:可以是变量,也可以是常量
构造方法:有构造方法
成员方法:可以是抽象方法,也可以是非抽象方法
接口:
成员变量:只能是常量。默认修饰符 public static final
成员方法:只能是抽象方法。默认修饰符 public abstract
B:关系区别
类与类:
继承关系。只能单继承,可以多层(重)继承。
类与接口:
实现关系。可以单实现,也可以多实现。
还可以在继承一个类的同时实现多个接口。
接口与接口:
继承关系。可以单继承,也可以多继承。
C:设计理念区别
抽象类被继承体现的是:"is a"的关系。抽象类定义的是共性功能。
接口被实现体现的是:"like a"的关系。接口定义的是扩展功能。
1.如何表达这个关系呢?
通过extends关键字可以实现类与类的继承
格式:
class 子类名 extends 父类名 {}
父类:基类,超类
子类:派生类
例: 学生类:
成员变量:name,age
构造方法:无参,带参
成员方法:getXxx()/setXxx(),eat(),sleep()
老师类:
成员变量:name,age
构造方法:无参,带参
成员方法:getXxx()/setXxx(),eat(),sleep()
2.用继承的思想来做
成员变量:name,age
构造方法:无参,带参
成员方法:getXxx()/setXxx(),eat(),sleep()
学生类:老师类,都继承人类
优点: A:提高了代码的复用性
多个类相同的成员可以放到同一个类中
B:提高了代码的维护性
如果功能的代码需要修改,修改一处即可
C:让类与类之间产生了关系,是多态的前提
1.必须存在继承关系
2.父类的方法满足不了你的需求,此时你就需要重写父类的方法,实现自己想要实现的功能
继承的特点:
A:Java只支持单继承,不支持多继承。一次只能继承一个父类
B:Java支持多层(重)继承(继承体系)。(父类还可以继承)
继承中类之间体现的是:”is a”的关系
3.类的组成:成员变量 构造方法 成员方法
继承间的成员变量关系:
A:名字不同,非常简单。
B:名字相同
首先在子类局部范围找
然后在子类成员范围找
最后在父类成员范围找(肯定不能访问到父类局部范围)
如果还是没有就报错。(不考虑父亲的父亲…)
就近原则。
需求:
请在show方法中输出4,3,2,1
class Fu {
public int num = 1;
}
class Zi extends Fu {
public int num2 = 2;
public int num = 3;
public void show() {
int num = 4;
int a=this.num;
int b = super.num;
System.out.print(num);
System.out.print(a);
System.out.print(num2);
System.out.print(b);
}
}
class ExtendsTest {
public static void main(String[] args) {
Zi z = new Zi();
z.show();
}
}
怎么去访问父亲的成员呢?
java就提供了一个关键字:super
super:
super代表父类存储空间的标识(可以理解为父类对象)
this和super的使用区别?
A:成员变量
this.成员变量 本类的成员变量
super.成员变量 父类的成员变量
B:成员方法
this.成员方法() 本类的成员方法
super.成员方法()父类的成员方法
4.继承间的成员方法关系:
A:方法名不同,非常简单
B:方法名相同
首先在子类中找
然后在父类中找
如果还是没有就报错。(不考虑父类的父类…)
1.7
继承间构造方法的关系:
子类中所有的构造方法默认都会访问父类中空参数的构造方法
因为子类会继承父类中的数据,可能还会使用父类的数据。
所以,子类初始化之前,一定要先完成父类数据的初始化。
每个子类的构造方法的第一行,有一条默认的语句:
super();
注意:仅仅是完成数据的初始化,创建对象目前必须用new申请空间。
假如父类没有无参构造方法,该怎么办呢?
A:调用父类的其他构造方法。带参构造。
怎么访问呢?
super(...)
注意:
super(…)或者this(….)必须出现在第一条语句上。
因为如果可以放后面的话,就会对父类的数据进程多次初始化。所以,只能放在第一条语句上。
无参构造最好自己给出。
二:final关键字
在实际开发的时候,有些方法的内容一旦写定后,就不允许被改动。
即时是子类,也不允许。那么该怎么解决这个问题呢?
java为了解决这样的问题就提供了一个关键字:final
final:
最终的意思。它可以修饰类,方法,变量。
特点:
修饰方法,方法不能被重写。
【重点】修饰类,类不能被继承。
修饰变量,变量的值不能再改动。其实这个时候变量已经变成了常量。
常量:
A:字面值常量
'a',12,"hello"
B:自定义常量
就是把变量用final修饰。
定义一个常量。
final 数据类型 变量名;
final int MAX_AGE = 20;
三:多态
多态:同一个对象,在不同时刻表现出来的不同状态。
多态的前提:
A:有继承关系
B:有方法重写(不是必要条件,但是只有有了方法重写多态才有意义)
C:有父类引用指向子类对象
Fu f = new Fu();
左边:Fu类型的引用
右边:Fu类型的对象
Zi z = new Zi();
Fu f = new Zi();父类引用指向子类对象
成员访问特点
A:成员变量
编译看左边,运行看左边
B:构造方法
子类构造默认访问父类的无参构造
C:成员方法(重点理解)
编译看左边,运行看右边
为什么变量和方法不一样呢?
方法重写。
D:静态成员方法
编译看左边,运行看左边
因为静态的内容是和类相关的,与对象无关。(静态-随着类的加载而加载,与创不创建无关)
练习:
看程序写结果(先判断有没有问题,如果没有,写出结果)
class Fu {
public void show() {
System.out.println("fu show");
}
}
class Zi extends Fu {
public void show() {
System.out.println("zi show");
}
public void method() {
System.out.println("zi method");
}
}
class DuoTaiTest {
public static void main(String[] args) {
Fu f = new Zi();
f.method(); //false
f.show(); //zi show
}
}
练习:(猫狗案例演示)
如何使用子类特有功能
A:创建子类对象
B:把父类引用转为子类对象
向上转型
从子到父
父类引用指向子类对象
向下转型
从父到子
父类引用转为子类对象
四:抽象类
4.1
抽象类特点:
A:抽象类和抽象方法必须用abstract关键字修饰
B:抽象类不一定有抽象方法,有抽象方法的类一定是抽象类
C:抽象类不能实例化
那么,如果实例化并使用呢?
按照多态的方式,由具体的子类实例化。其实这也是多态的一种,抽象类多态。
D:抽象类的子类
要么是抽象类
要么重写抽象类中的所有抽象方法
抽象类的作用:
强制要求子类必须要重写某些方法。
4.2
抽象类 -- 特点 -- 成员特点 -- 案例
类的组成:
成员变量:
构造方法:
成员方法:
抽象类的成员:
成员变量:可以是变量,也可以是常量。
构造方法:有构造方法
不能实例化,构造方法有什么用呢?
用于子类访问父类数据的初始化。
成员方法:既可以是抽象的,也可以是非抽象的。
五、多态:
具体类多态
class Fu {}
class Zi extends Fu {}
抽象类多态
abstract class Fu {}
class Zi extends Fu {}
接口多态
多态的前提:
继承
方法重写
因为抽象类中的方法是抽象方法。
父类引用指向子类对象
五:接口
认识接口:不是我们现实生活中的usb接口等等实物的接口,类实现接口代表着这个类自身功能的一种扩展,所以接口代表着一种扩展的能力
接口的特点:
A:定义接口要用关键字interface表示
格式:interface 接口名 {}
B:类实现接口用implements表示
格式:class 类名 implements 接口名 {}
C:接口不能实例化
那么,接口如何实例化呢?
按照多态的方式,由具体的子类实例化。其实这也是多态的一种,接口多态。
D:接口的实现类
要么是抽象类
要么重写接口中的所有抽象方法
多态的前提:
A:有继承或者实现关系
B:有方法重写
C:有父类引用或者父接口引用指向子类或者实现类对象
多态分类:
A:具体类多态
B:抽象类多态
C:接口多态
接口的成员特点:
A:成员变量
只能是常量。
默认修饰符:public static final
B:构造方法
没有构造方法
C:成员方法
只能是抽象方法。
默认修饰符:public abstract
类与类:
继承关系。只能单继承,可以多层(重)继承。
类与接口:
实现关系。可以单实现,也可以多实现。
还可以在继承一个类的同时实现多个接口。
接口与接口:
继承关系。可以单继承,也可以多继承。
接口和抽象类的关系最后分析:
抽象类和接口的区别
A:成员区别
抽象类:
成员变量:可以是变量,也可以是常量
构造方法:有构造方法
成员方法:可以是抽象方法,也可以是非抽象方法
接口:
成员变量:只能是常量。默认修饰符 public static final
成员方法:只能是抽象方法。默认修饰符 public abstract
B:关系区别
类与类:
继承关系。只能单继承,可以多层(重)继承。
类与接口:
实现关系。可以单实现,也可以多实现。
还可以在继承一个类的同时实现多个接口。
接口与接口:
继承关系。可以单继承,也可以多继承。
C:设计理念区别
抽象类被继承体现的是:"is a"的关系。抽象类定义的是共性功能。
接口被实现体现的是:"like a"的关系。接口定义的是扩展功能。