java继承和多态_Java基础继承与多态
Java基础第九天
继承概述
引入
首先我来写两个代码：
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15//定义学生类
class Student
{
public void study(){
System.out.println("在教室学习");
}
}
//定义老师类
class Teacher
{
public void teach(){
System.out.println("在教室教书");
}
}
我们观察上面两个代码：
发现name，age成员变量，以及getXxx()/setXxx(),还有eat()等都是相同的。
如果我们后来继续定义类，举例：工人类，军人类。他们是不是也具备这些内容。
那么，我们每一次定义这样的类的时候，都要把这些重复的内容都重新定义一遍。
麻烦不?麻烦。所以，我们要考虑改进?
如何改进呢?
我这样想的：我能不能把这些相同的内容给定义到一个独立的类中。
然后，让这多个类和这个独立的类产生一个关系，有了这个关系后，
这多个类就可以具备这个独立的类的功能。
为了实现这个效果，java就提供了一个技术：继承。
父亲：
4个儿子
继承怎么表示呢?继承的格式是什么样子的呢?
1
2
3
4
5class Fu {}
class Ziextends Fu {
}
我们就回头修改我们的代码：
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30class Person
{
String name;
int age;
public void eat(){
System.out.println("吃饭");
}
}
class Studentextends Person
{
public void study(){
System.out.println("在教室学习");
}
}
class Teacherextends Person
{
public void teach(){
System.out.println("在教室教书");
}
}
class Workerextends Person
{
public void work(){
System.out.println("在工作");
}
}
继承概述
多个类中存在相同属性和行为时，将这些内容抽取到单独一个类中，那么多个类无需再定义这些属性和行为，只要继承那个类即可。
通过extends关键字可以实现类与类的继承
class子类名extends父类名 {}
单独的这个类称为父类，基类或者超类；这多个类可以称为子类或者派生类。
有了继承以后，我们定义一个类的时候，可以在一个已经存在的类的基础上，还可以定义自己的新成员。
继承的案例和继承的好处
通过一个具体案例来演示代码
案例1：学生类和老师。定义两个功能(吃饭，睡觉)
案例2：加入人类后改进。
/*
继承概述：
把多个类中相同的内容给提取出来定义到一个类中。
如何实现继承呢?
Java提供了关键字：extends
格式：
class 子类名extends父类名{}
好处：
A:提高了代码的复用性
B:提高了代码的维护性
C:让类与类之间产生了关系，是多态的前提
*/
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47class Person
{
String name;
int age;
public void eat(){
System.out.println("吃饭");
}
}
class Studentextends Person
{
public void study(){
System.out.println("在教室学习");
}
}
class Teacherextends Person
{
public void teach(){
System.out.println("在教室教书");
}
}
class Workerextends Person
{
public void work(){
System.out.println("在工作");
}
}
class PersonTest
{
public static void main(String[] args)
{
Student s =new Student();
s.eat();
s.study();
Teacher t =new Teacher();
t.eat();
t.teach();
Worker w =new Worker();
w.eat();
w.work();
System.out.println("Hello World!");
}
}
继承的好处
提高了代码的复用性
多个类相同的成员可以放到同一个类中
提高了代码的维护性
如果功能的代码需要修改，修改一处即可
让类与类之间产生了关系，是多态的前提
Java中继承的特点
Java只支持单继承，不支持多继承。
一个类只能有一个父类，不可以有多个父类。
class SubDemo extends Demo{} //ok
class SubDemo extends Demo1,Demo2...//error
Java支持多层继承(继承体系)
class A{}
class B extends A{}
class C extends B{}
/*
Java中继承的特点：
A:Java只支持单继承，不支持多继承。
有些语言是支持多继承，格式：extends 类1,类2,...
B:Java支持多层继承(继承体系)
*/
/*
class Father {}
class Mother {}
class Son exnteds Father {} //正确的
class Son extends Father,Mother {} // 错误的
*/
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21class GrandFather {
public void show() {
System.out.println("我是爷爷");
}
}
class Fatherextends GrandFather {
public void method(){
System.out.println("我是老子");
}
}
class Sonextends Father {}
class ExtendsDemo2 {
public static void main(String[] args) {
Son s =new Son();
s.method();//使用父亲的
s.show();//使用爷爷的
}
}
Java中继承的注意事项
子类只能继承父类所有非私有的成员(成员方法和成员变量)
其实这也体现了继承的另一个弊端：打破了封装性
子类不能继承父类的构造方法，但是可以通过super(后面讲)关键字去访问父类构造方法。
不要为了部分功能而去继承
我们到底在什么时候使用继承呢?
继承中类之间体现的是：”is a”的关系。
/*
继承的注意事项：
A:子类只能继承父类所有非私有的成员(成员方法和成员变量)
B:子类不能继承父类的构造方法，但是可以通过super(马上讲)关键字去访问父类构造方法。
C:不要为了部分功能而去继承
class A {
public void show1(){}
public void show2(){}
}
class B {
public void show2(){}
public void show3(){}
}
//我们发现B类中出现了和A类一样的show2()方法，所以，我们就用继承来体现
class B extends A {
public void show3(){}
}
这样其实不好，因为这样你不但有了show2(),还多了show1()。
有可能show1()不是你想要的。
那么，我们什么时候考虑使用继承呢?
继承其实体现的是一种关系："is a"。
Person
Student
Teacher
水果
苹果
香蕉
橘子
采用假设法。
如果有两个类A,B。只有他们符合A是B的一种，或者B是A的一种，就可以考虑使用继承。
*/
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42class GrandFather
{
public int num1 =10;
public void show(){
System.out.println("我是爷爷");
}
}
class Fatherextends GrandFather
{
public int num2 =100;
public int num1 =100000;
public void method(){
int num3 =1000;
int num1 =20;
System.out.println("我是老子");
System.out.println(super.num1);
System.out.println(num3);
System.out.println(num1);
System.out.println(this.num1);
}
}
class Sonextends Father
{
public void fuction(){
System.out.println(super.num1);
System.out.println(num2);
}
}
class ExtendsDemo2
{
public static void main(String[] args)
{
Son son =new Son();
son.show();
son.method();
son.fuction();
System.out.println("Hello World!");
}
}
继承中成员变量的关系
案例演示
子父类中同名和不同名的成员变量
/*
类的组成：
成员变量：
构造方法：
成员方法：
而现在我们又讲解了继承，所以，我们就应该来考虑一下，类的组成部分的各自关系。
继承中成员变量的关系:
A:子类中的成员变量和父类中的成员变量名称不一样，这个太简单。
B:子类中的成员变量和父类中的成员变量名称一样，这个怎么玩呢?
在子类方法中访问一个变量的查找顺序：
a:在子类方法的局部范围找，有就使用
b:在子类的成员范围找，有就使用
c:在父类的成员范围找，有就使用
d:如果还找不到，就报错。
*/
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21class Father {
public int num =10;
}
class Sonextends Father {
public int num =20;
public void show() {
int num =30;
System.out.println(num);
System.out.println(this.num);
System.out.println(super.num);
}
}
class ExtendsDemo5 {
public static void main(String[] args) {
Son s =new Son();
s.show();
}
}
继承中构造方法的关系
子类中所有的构造方法默认都会访问父类中空参数的构造方法
为什么呢?
因为子类会继承父类中的数据，可能还会使用父类的数据。所以，子类初始化之前，一定要先完成父类数据的初始化。
每一个构造方法的第一条语句默认都是：super()
/*
继承中构造方法的关系
A:子类中所有的构造方法默认都会访问父类中空参数的构造方法
B:为什么呢?
因为子类会继承父类中的数据，可能还会使用父类的数据。
所以，子类初始化之前，一定要先完成父类数据的初始化。
注意：子类每一个构造方法的第一条语句默认都是：super();
*/
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32class Father {
int age;
public Father() {
System.out.println("Father的无参构造方法");
}
public Father(String name) {
System.out.println("Father的带参构造方法");
}
}
class Sonextends Father {
public Son() {
//super();
System.out.println("Son的无参构造方法");
}
public Son(String name) {
//super();
System.out.println("Son的带参构造方法");
}
}
class ExtendsDemo6 {
public static void main(String[] args) {
//创建对象
Son s =new Son();
System.out.println("------------");
Son s2 =new Son("林青霞");
}
}
如何父类中没有构造方法，该怎么办呢?
子类通过super去显示调用父类其他的带参的构造方法
子类通过this去调用本类的其他构造方法
本类其他构造也必须首先访问了父类构造
一定要注意：
super(…)或者this(….)必须出现在第一条语句上
否则，就会有父类数据的多次初始化
/*
如果父类没有无参构造方法，那么子类的构造方法会出现什么现象呢?
报错。
如何解决呢?
A:在父类中加一个无参构造方法
B:通过使用super关键字去显示的调用父类的带参构造方法
C:子类通过this去调用本类的其他构造方法
子类中一定要有一个去访问了父类的构造方法，否则父类数据就没有初始化。
注意事项：
this(...)或者super(...)必须出现在第一条语句上。
如果不是放在第一条语句上，就可能对父类的数据进行了多次初始化，所以必须放在第一条语句上。
*/
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32class Father {
/*
public Father() {
System.out.println("Father的无参构造方法");
}
*/
public Father(String name) {
System.out.println("Father的带参构造方法");
}
}
class Sonextends Father {
public Son() {
super("随便给");
System.out.println("Son的无参构造方法");
//super("随便给");
}
public Son(String name) {
//super("随便给");
this();
System.out.println("Son的带参构造方法");
}
}
class ExtendsDemo7 {
public static void main(String[] args) {
Son s =new Son();
System.out.println("----------------");
Son ss =new Son("林青霞");
}
}
面试题一
/*
看程序写结果：
A:成员变量就近原则
B:this和super的问题
this访问本类的成员
super访问父类的成员
C:子类构造方法执行前默认先执行父类的无参构造方法
D:一个类的初始化过程
成员变量进行初始化
默认初始化
显示初始化
构造方法初始化
结果：
fu
zi
30
20
10
*/
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31class Fu
{
public int num =10;
public Fu(){
System.out.println("fu");
}
}
class Ziextends Fu
{
public int num =20;
public Zi(){
System.out.println("Zi");
}
public void show(){
int num =30;
System.out.println(num);//30
System.out.println(this.num);//20
System.out.println(super.num);//10
}
}
class ExtendsTest
{
public static void main(String[] args)
{
Zi z =new Zi();
z.show();
System.out.println("Hello World!");
}
}
面试题二
/*
看程序写结果：
A:一个类的静态代码块,构造代码块,构造方法的执行流程
静态代码块 > 构造代码块 >构造方法
B:静态的内容是随着类的加载而加载
静态代码块的内容会优先执行
C:子类初始化之前先会进行父类的初始化
结果是：
静态代码块Fu
静态代码块Zi
构造代码块Fu
构造方法Fu
构造代码块Zi
构造方法Zi
*/
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39class Fu
{
static{
System.out.println("静态代码块Fu");
}
{
System.out.println("构造代码块Fu");
}
public Fu(){
System.out.println("构造方法Fu");
}
}
class Ziextends Fu
{
static{
System.out.println("静态代码块Zi");
}
{
System.out.println("构造代码块Zi");
}
public Zi(){
//super();
System.out.println("构造方法Zi");
}
}
class ExtendsTest2
{
public static void main(String[] args)
{
Zi z =new Zi();
System.out.println("Hello World!");
}
}
继承中成员方法的关系
案例演示
子父类中同名和不同名的成员方法
结论：
通过子类对象去访问一个方法
首先在子类中找
然后在父类中找
如果还是没有就报错。(不考虑父亲的父亲…)
/*
继承中成员方法的关系:
A:子类中的方法和父类中的方法声明不一样，这个太简单。
B:子类中的方法和父类中的方法声明一样，这个该怎么玩呢?
通过子类对象调用方法：
a:先找子类中，看有没有这个方法，有就使用
b:再看父类中，有没有这个方法，有就使用
c:如果没有就报错。
*/
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25class Father {
public void show() {
System.out.println("show Father");
}
}
class Sonextends Father {
public void method() {
System.out.println("method Son");
}
public void show() {
System.out.println("show Son");
}
}
class ExtendsDemo8 {
public static void main(String[] args) {
//创建对象
Son s =new Son();
s.show();
s.method();
//s.fucntion(); //找不到符号
}
}
方法重写概述
方法重写概述
子类中出现了和父类中一模一样的方法声明，也被称为方法覆盖，方法复写。
使用特点：
如果方法名不同，就调用对应的方法
如果方法名相同，最终使用的是子类自己的
方法重写的应用：
当子类需要父类的功能，而功能主体子类有自己特有内容时，可以重写父类中的方法，这样，即沿袭了父类的功能，又定义了子类特有的内容。
/*
方法重写：子类中出现了和父类中方法声明一模一样的方法。
方法重载：
本类中出现的方法名一样，参数列表不同的方法。与返回值无关。
子类对象调用方法的时候：
先找子类本身，再找父类。
方法重写的应用：
当子类需要父类的功能，而功能主体子类有自己特有内容时，可以重写父类中的方法。
这样，即沿袭了父类的功能，又定义了子类特有的内容。
案例：
A:定义一个手机类。
B:通过研究，我发明了一个新手机，这个手机的作用是在打完电话后，可以听天气预报。
按照我们基本的设计，我们把代码给写出来了。
但是呢?我们又发现新手机应该是手机，所以，它应该继承自手机。
其实这个时候的设计，并不是最好的。
因为手机打电话功能，是手机本身就具备的最基本的功能。
所以，我的新手机是不用在提供这个功能的。
但是，这个时候，打电话功能就没有了。这个不好。
最终，还是加上这个功能。由于它继承了手机类，所以，我们就直接使用父类的功能即可。
那么，如何使用父类的功能呢?通过super关键字调用
*/
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20class Phone {
public void call(String name) {
System.out.println("给"+name+"打电话");
}
}
class NewPhoneextends Phone {
public void call(String name) {
//System.out.println("给"+name+"打电话");
super.call(name);
System.out.println("可以听天气预报了");
}
}
class ExtendsDemo9 {
public static void main(String[] args) {
NewPhone np =new NewPhone();
np.call("林青霞");
}
}
方法重写的注意事项
父类中私有方法不能被重写
子类重写父类方法时，访问权限不能更低
父类静态方法，子类也必须通过静态方法进行重写。(其实这个算不上方法重写，但是现象确实如此，至于为什么算不上方法重写，多态中我会讲解)
/*
方法重写的注意事项
A:父类中私有方法不能被重写
因为父类私有方法子类根本就无法继承
B:子类重写父类方法时，访问权限不能更低
最好就一致
C:父类静态方法，子类也必须通过静态方法进行重写
其实这个算不上方法重写，但是现象确实如此，至于为什么算不上方法重写，多态中我会讲解
子类重写父类方法的时候，最好声明一模一样。
*/
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54class Father {
//private void show() {}
/*
public void show() {
System.out.println("show Father");
}
*/
void show() {
System.out.println("show Father");
}
/*
public static void method() {
}
*/
public void method() {
}
}
class Son extends Father {
//private void show() {}
/*
public void show() {
System.out.println("show Son");
}
*/
public void show() {
System.out.println("show Son");
}
public static void method() {
}
/*
public void method() {
}
*/
}
class ExtendsDemo10 {
public static void main(String[] args) {
Son s =new Son();
s.show();
}
}
面试题
1：方法重写和方法重载的区别?方法重载能改变返回值类型吗?
方法重写：
在子类中，出现和父类中一模一样的方法声明的现象。
方法重载：
同一个类中，出现的方法名相同，参数列表不同的现象。
方法重载能改变返回值类型，因为它和返回值类型无关。
Override：方法重写
Overload：方法重载
2：this关键字和super关键字分别代表什么?以及他们各自的使用场景和作用。
this:代表当前类的对象引用
super:代表父类存储空间的标识。(可以理解为父类的引用，通过这个东西可以访问父类的成员)
场景：
成员变量：
this.成员变量
super.成员变量
构造方法：
this(...)
super(...)
成员方法：
this.成员方法
super.成员方法
继承练习
学生案例和老师案例讲解
使用继承前
使用继承后
父类中成员private修饰，子类如何访问呢?
/*
学生案例和老师案例讲解
学生：
成员变量；姓名，年龄
构造方法：无参，带参
成员方法：getXxx()/setXxx()
老师：
成员变量；姓名，年龄
构造方法：无参，带参
成员方法：getXxx()/setXxx()
看上面两个类的成员，发现了很多相同的东西，所以我们就考虑抽取一个共性的类：
人：
成员变量；姓名，年龄
构造方法：无参，带参
成员方法：getXxx()/setXxx()
学生 继承 人
老师 继承 人
*/
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89class Person
{
//姓名
private String name;
private int age;
public Person(){
}
public Person(String name,int age){
this.name = name;
this.age = age;
}
public void setName(String name){
this.name = name;
}
public String getName(){
return name;
}
public void setAge(int age){
this.age = age;
}
public int getAge(){
return age;
}
}
class Studentextends Person
{
public Student(){
}
public Student(String name,int age){
super(name,age);
}
}
class Teacherextends Person
{
public Teacher(){
}
public Teacher(String name,int age){
super(name,age);
}
}
class Workerextends Person
{
public Worker(){
}
public Worker(String name,int age){
super(name,age);
}
}
class ExtendsTest4
{
public static void main(String[] args)
{
Student s1 =new Student();
s1.setName("林青霞");
s1.setAge(27);
System.out.println(s1.getName()+" \t"+s1.getAge());
Student s2 =new Student("杨幂",23);
System.out.println(s2.getName()+" \t"+s2.getAge());
Teacher t1 =new Teacher();
t1.setName("邓丽君");
t1.setAge(38);
System.out.println(t1.getName()+" \t"+t1.getAge());
Teacher t2 =new Teacher("张三丰",54);
System.out.println(t2.getName()+" \t"+t2.getAge());
Worker w1 =new Worker();
w1.setName("杨过");
w1.setAge(25);
System.out.println(w1.getName()+" \t"+w1.getAge());
Worker w2 =new Worker("李思思",36);
System.out.println(w2.getName()+" \t"+w2.getAge());
}
}
猫狗案例讲解
分析和实现
/*
猫狗案例讲解
先找到具体的事物，然后发现具体的事物有共性，才提取出一个父类。
猫：
成员变量：姓名，年龄，颜色
构造方法：无参，带参
成员方法：
getXxx()/setXxx()
eat()
palyGame()
狗：
成员变量：姓名，年龄，颜色
构造方法：无参，带参
成员方法：
getXxx()/setXxx()
eat()
lookDoor()
共性：
成员变量：姓名，年龄，颜色
构造方法：无参，带参
成员方法：
getXxx()/setXxx()
eat()
把共性定义到一个类中，这个类的名字叫：动物。
动物类：
成员变量：姓名，年龄，颜色
构造方法：无参，带参
成员方法：
getXxx()/setXxx()
eat()
猫：
构造方法：无参，带参
成员方法：palyGame()
狗：
构造方法：无参，带参
成员方法：lookDoor()
*/
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95class Animal
{
private String name;
private int age;
private String color;
public Animal(){}
public Animal(String name,int age,String color){
this.name = name;
}
public void setName(String name){
this.name = name;
this.age = age;
this.color = color;
}
public String getName(){
return name;
}
public void setAge(int age){
this.age = age;
}
public int getAge(){
return age;
}
public void setColor(String color){
this.color = color;
}
public String getColor(){
return color;
}
public void eat(){
System.out.println("别睡了，起来吃饭吧");
}
}
class Catextends Animal
{
public Cat(){}
public Cat(String name,int age,String color){
super(name,age,color);
}
public void playGame(){
System.out.println("猫玩英雄联盟");
}
}
class Dogextends Animal
{
public Dog(){}
public Dog(String name,int age,String color){
super(name,age,color);
}
public void lookDoor(){
System.out.println("狗看家");
}
}
class ExtendsTest5
{
public static void main(String[] args)
{
Cat c1 =new Cat();
c1.setName("Tom");
c1.setAge(3);
c1.setColor("白色");
System.out.println("猫的名字是："+c1.getName()+";年龄是："+c1.getAge()+";颜色是："+c1.getColor());
c1.eat();
c1.playGame();
System.out.println("---------------");
Cat c2 =new Cat("杰瑞",5,"土豪金");
System.out.println("猫的名字是："+c2.getName()+";年龄是："+c2.getAge()+";颜色是："+c2.getColor());
c2.eat();
c2.playGame();
System.out.println("---------------");
Dog d1 =new Dog();
d1.setName("Tom");
d1.setAge(3);
d1.setColor("白色");
System.out.println("狗的名字是："+d1.getName()+";年龄是："+d1.getAge()+";颜色是："+d1.getColor());
d1.eat();
d1.lookDoor();
System.out.println("---------------");
Dog d2 =new Dog("杰瑞",5,"土豪金");
System.out.println("狗的名字是："+d2.getName()+";年龄是："+d2.getAge()+";颜色是："+d2.getColor());
d2.eat();
d2.lookDoor();
}
}
final关键字
final关键字是最终的意思，可以修饰类，成员变量，成员方法。
修饰类，类不能被继承
修饰变量，变量就变成了常量，只能被赋值一次
修饰方法，方法不能被重写
/*
继承的代码体现
由于继承中方法有一个现象：方法重写。
所以，父类的功能，就会被子类给覆盖调。
有些时候，我们不想让子类去覆盖掉父类的功能，只能让他使用。
这个时候，针对这种情况，Java就提供了一个关键字：final
final:最终的意思。常见的是它可以修饰类，方法，变量。
*/
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19class Fu {
public final void show() {
System.out.println("这里是绝密资源,任何人都不能修改");
}
}
class Ziextends Fu {
// Zi中的show()无法覆盖Fu中的show()
public void show() {
System.out.println("这是一堆垃圾");
}
}
class ZiDemo {
public static void main(String[] args) {
Zi z =new Zi();
z.show();
}
}
Final特性
/*
final可以修饰类，方法，变量
特点：
final可以修饰类，该类不能被继承。
final可以修饰方法，该方法不能被重写。(覆盖，复写)
final可以修饰变量，该变量不能被重新赋值。因为这个变量其实常量。
常量：
A:字面值常量
"hello",10,true
B:自定义常量
final int x = 10;
*/
//final class Fu //无法从最终Fu进行继承
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29class Fu {
public int num =10;
public final int num2 =20;
/*
public final void show() {
}
*/
}
class Ziextends Fu {
// Zi中的show()无法覆盖Fu中的show()
public void show() {
num =100;
System.out.println(num);
//无法为最终变量num2分配值
//num2 = 200;
System.out.println(num2);
}
}
class FinalDemo {
public static void main(String[] args) {
Zi z =new Zi();
z.show();
}
}
final关键字面试题
final修饰局部变量
在方法内部，该变量不可以被改变
在方法声明上，分别演示基本类型和引用类型作为参数的情况
基本类型，是值不能被改变
引用类型，是地址值不能被改变
/*
面试题：final修饰局部变量的问题
基本类型：基本类型的值不能发生改变。
引用类型：引用类型的地址值不能发生改变，但是，该对象的堆内存的值是可以改变的。
*/
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33class Student {
int age =10;
}
class FinalTest {
public static void main(String[] args) {
//局部变量是基本数据类型
int x =10;
x =100;
System.out.println(x);
final int y =10;
//无法为最终变量y分配值
//y = 100;
System.out.println(y);
System.out.println("--------------");
//局部变量是引用数据类型
Student s =new Student();
System.out.println(s.age);
s.age =100;
System.out.println(s.age);
System.out.println("--------------");
final Student ss =new Student();
System.out.println(ss.age);
ss.age =100;
System.out.println(ss.age);
//重新分配内存空间
//无法为最终变量ss分配值
ss =new Student();
}
}
final修饰变量的初始化时机
在对象构造完毕前即可
/*
final修饰变量的初始化时机
A:被final修饰的变量只能赋值一次。
B:在构造方法完毕前。(非静态的常量)
*/
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25class Demo {
//int num = 10;
//final int num2 = 20;
int num;
final int num2;
{
//num2 = 10;
}
public Demo() {
num =100;
//无法为最终变量num2分配值
num2 =200;
}
}
class FinalTest2 {
public static void main(String[] args) {
Demo d =new Demo();
System.out.println(d.num);
System.out.println(d.num2);
}
}
多态
多态概述
某一个事物，在不同时刻表现出来的不同状态。
举例：
猫可以是猫的类型。猫 m = new 猫();
同时猫也是动物的一种，也可以把猫称为动物。
动物 d = new 猫();
在举一个例子：水在不同时刻的状态
多态前提和体现
有继承关系
有方法重写
有父类引用指向子类对象
多态案例及成员访问特点
/*
多态：同一个对象(事物)，在不同时刻体现出来的不同状态。
举例：
猫是猫，猫是动物。
水(液体，固体，气态)。
多态的前提：
A:要有继承关系。
B:要有方法重写。
其实没有也是可以的，但是如果没有这个就没有意义。
动物 d = new 猫();
d.show();
动物 d = new 狗();
d.show();
C:要有父类引用指向子类对象。
父 f = new 子();
用代码体现一下多态。
多态中的成员访问特点：
A:成员变量
编译看左边，运行看左边。
B:构造方法
创建子类对象的时候，访问父类的构造方法，对父类的数据进行初始化。
C:成员方法
编译看左边，运行看右边。
D:静态方法
编译看左边，运行看左边。
(静态和类相关，算不上重写，所以，访问还是左边的)
由于成员方法存在方法重写，所以它运行看右边。
*/
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44class Fu {
public int num =100;
public void show() {
System.out.println("show Fu");
}
public static void function() {
System.out.println("function Fu");
}
}
class Ziextends Fu {
public int num =1000;
public int num2 =200;
public void show() {
System.out.println("show Zi");
}
public void method() {
System.out.println("method zi");
}
public static void function() {
System.out.println("function Zi");
}
}
class DuoTaiDemo {
public static void main(String[] args) {
//要有父类引用指向子类对象。
//父 f = new 子();
Fu f =new Zi();
System.out.println(f.num);
//找不到符号
//System.out.println(f.num2);
f.show();
//找不到符号
//f.method();
f.function();
}
}
成员访问特点
成员变量
编译看左边，运行看左边
成员方法
编译看左边，运行看右边
静态方法
编译看左边，运行看左边
所以前面我说静态方法不能算方法的重写
多态的好处
提高了程序的维护性(由继承保证)
提高了程序的扩展性(由多态保证)
/*
多态的好处：
A:提高了代码的维护性(继承保证)
B:提高了代码的扩展性(由多态保证)
猫狗案例代码
*/
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61class Animal
{
public void eat(){
System.out.println("eat");
}
public void sleep(){
System.out.println("sleep");
}
}
class Catextends Animal
{
public void eat(){
System.out.println("猫吃鱼");
}
public void sleep(){
System.out.println("猫趴着睡");
}
}
class Dogextends Animal
{
public void eat(){
System.out.println("狗吃肉");
}
public void sleep(){
System.out.println("狗站着睡");
}
}
class Ultramanextends Animal
{
public void eat(){
System.out.println("奥特曼打小怪兽");
}
public void sleep(){
System.out.println("奥特曼不用睡觉");
}
}
class AnimalTools
{
public static void animalTools(Animal a){
a.eat();
a.sleep();
}
}
class DuoTai
{
public static void main(String[] args)
{
Animal cat =new Cat();
AnimalTools.animalTools(cat);
Animal dog =new Dog();
AnimalTools.animalTools(dog);
Animal ultraman =new Ultraman();
AnimalTools.animalTools(ultraman);
//System.out.println("Hello World!");
}
}
多态的弊端
不能访问子类特有功能
那么我们如何才能访问子类的特有功能呢?
多态中的转型
/*
多态的弊端：
不能使用子类的特有功能。
*/
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25class Fu {
public void show() {
System.out.println("show fu");
}
}
class Ziextends Fu {
public void show() {
System.out.println("show zi");
}
public void method() {
System.out.println("method zi");
}
}
class DuoTaiDemo3 {
public static void main(String[] args) {
//测试
Fu f =new Zi();
f.show();
f.method();
}
}
多态中的转型问题
向上转型
从子到父
父类引用指向子类对象
向下转型
从父到子
父类引用转为子类对象
/*
多态的弊端：
不能使用子类的特有功能。
我就想使用子类的特有功能?行不行?
行。
怎么用呢?
A:创建子类对象调用方法即可。(可以，但是很多时候不合理。而且，太占内存了)
B:把父类的引用强制转换为子类的引用。(向下转型)
对象间的转型问题：
向上转型：
Fu f = new Zi();
向下转型：
Zi z = (Zi)f; //要求该f必须是能够转换为Zi的。
*/
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36class Fu {
public void show() {
System.out.println("show fu");
}
}
class Ziextends Fu {
public void show() {
System.out.println("show zi");
}
public void method() {
System.out.println("method zi");
}
}
class DuoTaiDemo4 {
public static void main(String[] args) {
//测试
Fu f =new Zi();
f.show();
//f.method();
//创建子类对象
//Zi z = new Zi();
//z.show();
//z.method();
//你能够把子的对象赋值给父亲，那么我能不能把父的引用赋值给子的引用呢?
//如果可以，但是如下
Zi z = (Zi)f;
z.show();
z.method();
}
}
多态成员访问及转型的理解
多态的问题理解：
class 孔子爹 {
public int age = 40;
public void teach() {
System.out.println("讲解JavaSE");
}
}
class 孔子 extends孔子爹 {
public int age = 20;
public void teach() {
System.out.println("讲解论语");
}
public void playGame() {
System.out.println("英雄联盟");
}
}
//Java培训特别火,很多人来请孔子爹去讲课，这一天孔子爹被请走了
//但是还有人来请，就剩孔子在家，价格还挺高。孔子一想，我是不是可以考虑去呢?
//然后就穿上爹的衣服，带上爹的眼睛，粘上爹的胡子。就开始装爹
//向上转型
孔子爹 k爹 = new孔子();
//到人家那里去了
System.out.println(k爹.age); //40
k爹.teach(); //讲解论语
//k爹.playGame(); //这是儿子才能做的
//讲完了，下班回家了
//脱下爹的装备，换上自己的装备
//向下转型
孔子 k = (孔子) k爹;
System.out.println(k.age); //20
k.teach(); //讲解论语
k.playGame(); //英雄联盟
多态内存图
多态中对象变化的内存图解
/*
ClassCastException:类型转换异常
一般在多态的向下转型中容易出现
*/
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35class Animal {
public void eat(){}
}
class Dogextends Animal {
public void eat() {}
public void lookDoor() {
}
}
class Catextends Animal {
public void eat() {
}
public void playGame() {
}
}
class DuoTaiDemo5 {
public static void main(String[] args) {
//内存中的是狗
Animal a =new Dog();
Dog d = (Dog)a;
//内存中是猫
a =new Cat();
Cat c = (Cat)a;
//内存中是猫
Dog dd = (Dog)a;//ClassCastException
}
案例练习
/*
多态练习：猫狗案例
*/
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54class Animal {
public void eat(){
System.out.println("吃饭");
}
}
class Dogextends Animal {
public void eat() {
System.out.println("狗吃肉");
}
public void lookDoor() {
System.out.println("狗看门");
}
}
class Catextends Animal {
public void eat() {
System.out.println("猫吃鱼");
}
public void playGame() {
System.out.println("猫捉迷藏");
}
}
class DuoTaiTest {
public static void main(String[] args) {
//定义为狗
Animal a =new Dog();
a.eat();
System.out.println("--------------");
//还原成狗
Dog d = (Dog)a;
d.eat();
d.lookDoor();
System.out.println("--------------");
//变成猫
a =new Cat();
a.eat();
System.out.println("--------------");
//还原成猫
Cat c = (Cat)a;
c.eat();
c.playGame();
System.out.println("--------------");
//演示错误的内容
//Dog dd = new Animal();
//Dog ddd = new Cat();
//ClassCastException
//Dog dd = (Dog)a;
}
}
不同地方饮食文化不同的案例
Person
eat()
SouthPerson
eat()
NorthPerson
eat()
/*
不同地方饮食文化不同的案例
*/
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47class Person {
public void eat() {
System.out.println("吃饭");
}
}
class SouthPersonextends Person {
public void eat() {
System.out.println("炒菜,吃米饭");
}
public void jingShang() {
System.out.println("经商");
}
}
class NorthPersonextends Person {
public void eat() {
System.out.println("炖菜,吃馒头");
}
public void yanJiu() {
System.out.println("研究");
}
}
class DuoTaiTest2 {
public static void main(String[] args) {
//测试
//南方人
Person p =new SouthPerson();
p.eat();
System.out.println("-------------");
SouthPerson sp = (SouthPerson)p;
sp.eat();
sp.jingShang();
System.out.println("-------------");
//北方人
p =new NorthPerson();
p.eat();
System.out.println("-------------");
NorthPerson np = (NorthPerson)p;
np.eat();
np.yanJiu();
}
}