翔奕时代

A year's plan starts with spring.

0%

Java学习-part.04（继承、重写、super、多态、多态的引用类型转换、抽象类、接口）

发表于 更新于 分类于 7.4k 7 分钟

java中的继承

1、继承的概念：

继承是类与类的一种关系，是一中 “is a”的关系。

注：java中的继承是单继承

2、继承的好处

子类拥有父类的所有的属性和方法，但是父类中的private修饰符无效

实现代码复用
java

eg：生活有要是有个好爹，就可以少奋斗几年;如果继承了父亲的权力，那就是官二代

3、语法

1
2
3
4
class  子类 extends 父类 
例：class Dog extends Animal{
    ....
}
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
//父类
package com.imooc;

//重庆人
public class ChongQing {
	String area = "西南地区"; // 地区
	String love = "爱吃辣";   //喜好
	String beatiWoman = "美女多"; //美女多
	double population = 30000000;//人口
	public void work() {
		System.out.println("工作使我快乐！");
	}
	public void shoping() {
		System.out.println("重庆人是喜欢购物的");
	}
}



//子类
package com.imooc;

public class Xiexiang extends ChongQing {
	
	public void getChongqing() {
		System.out.print(area + "有个地方叫重庆，那里的人"+love+",而且" + beatiWoman + ",他们是很喜欢工作的，时常都会说：" );
		work();
	}
	
	public static void main(String[] args) {
		new Xiexiang().getChongqing(); 
	}
}

//运行结果

西南地区有个地方叫重庆，那里的人爱吃辣,而且美女多,他们是很喜欢工作的，时常都会说：工作使我快乐！

方法的重写

1、概念：

如果子类对继承父类的方法不满意，是可以重写父类继承的方法的，当调用方法时会优先调用子类的方法。

2、语法规则

语法规则

返回值类型

参数类型及个数

都要与父类继承的方法相同，才叫方法的重写。

final关键字

概念：使用final关键字做标识有”最终的”含义。

final可以修饰类、方法、属性和变量

  • final修饰类，则该类不允许被继承
  • final修饰方法，则该方法不允许被覆盖（重写）
  • final修饰属性，则该类的属性不会进行隐式的初始化（类的初始化属性必须有值）或是构造方法中赋值（但只能选其一）[就是属性只能赋值一次，不管是构造方法还是main方法都无法再次进行赋值]
  • final修饰变量，则该变量的值只能赋一次值，即为常量。

super关键字

super关键字：在对象的内部使用，可以代表父类对象

  • 访问父类的属性： super.love
  • 访问父类的方法： super.work()
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
package com.imooc;

public class Xiexiang extends ChongQing {
	public void work() {
		System.out.println("被重构之后的输出");
	}
	
	public void getChongqing() {
		System.out.print(super.area + "有个地方叫重庆，那里的人"+super.love+",而且" + super.beatiWoman + ",他们是很喜欢工作的，时常都会说：" );
		super.work();  //work方法被重写，使用super关键字后指向的是使用的是父类的work方法
		work();  //这种写法默认是重写后的方法
	}
	
	public static void main(String[] args) {
		new Xiexiang().getChongqing(); 
	}
}
  • super的应用*
  • 如果子类的构造方法中没有显示调用父类的构造方法，则系统默认调用父类无参的构造方法。
  • 如果显示的调用构造方法，必须在子类的构造方法的第一行。
  • 如果子类构造方法中既没有显示调用父类的构造方法，而父类又没有无参的构造方法，则会编译出错。

Object类

object类是所有类的父类，如果一个类没有使用extends关键字明确标识继承另外一个类，那么这个类默认继承Object类。

object类中的方法，适合所有的子类。

常用的方法：

  • 1、toString() 方法 返回值：字符串

    直接输出对象只能是返回哈希码生成的一个对象的内存地址，重写toString()方法能够清晰展现对象的属性值。

  • 2、equals()方法 返回值：bool

    比较的是对象的引用是否指向同一块内存地址
    一般情况下比较两个对象时比较他的值是否一致，所以要进行重写。
    java

多态 **

概念：对象的多种形态

1、引用的多态

父类的引用可以指向本类的对象

父类的引用可以指向子类的对象

eg:Dog类extends Animal类

Animal obj1 = new Animal();

Animal obj2 = new Dog(); //父类的引用是可以指向子类对象的

//Dog obj3 = new Animal(); //X 这种就是错误的

2、方法多态

创建本类对象时，调用的方法为本类的方法

创建子类对象时，调用的方法为子类重写的方法或者继承的方法。（__也就是说，子类里面非继承和重写的方法，是不能调用的__）

多态中的引用类型转换

  • 1、向上类型转换（隐式/自动类型转换），是小类型到大类型的转换；
  • 2、向下类型转换（强制类型转换），是大类型到小类型；
  • 3、instanceof运算符，来解决引用对象的类型，避免类型转换的安全性问题。
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
package com.imooc;

public class convertType {
	public static void main(String[] args) {
		Dog dog = new Dog();
		Animal animal = dog;  //自动类型提升，向上类型转换
		Dog dog2 = (Dog)animal; //强制类型转换  向下类型转换 [存在风险]
		Cat cat = (Cat)animal;  //风险点：编译器不会报错，但是运行时提示没有办法进行转换，Cat类型与Dog类型不一致
		
		
		//上面的代码都不严谨，可以用到instanceof做检测
		if(animal instanceof Cat) {  //避免类型转换的安全性问题
			Cat cat = (Cat)animal;
		}else {
			System.out.println("无法进行类型转换");
		}
	}
}

抽象类 **

1、语法定义：

抽象类前使用abstract关键字修饰，则该类为抽象类。

2、应用场景：

  • 在某些情况下，某个父类只是知道其子类应该包含怎样的方法，但无法准确知道这些子类如何实现这些方法；
  • 从多个具有相同特征的类中抽象出一个抽象类，以这个抽象类作为子类的模板，从而避免了子类设计的随意性。

3、作用 *

限制规定子类必须实现某些方法，但是不关注实现细节。

4、使用规则

  • abstract定义抽象类
  • abstract定义抽象方法，只有声明，不需要实现
  • 包含抽象方法的类是抽象类
  • 抽象类中可以包含普通的方法，也可以没有抽象方法
  • 抽象类不能直接创建，可以定义引用变量
    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
    package com.abstracttest;

    //图形抽象类
    public abstract class Mould {
    	
    	//面积的实现
    	public abstract double area(double chang,double kuan);
    	
    	//周长的实现
    	public abstract double girth(double chang,double kuan);
    }


    package com.abstracttest;

    //矩形
    public class Rectangle extends Mould {

    	@Override //矩形面积的计算
    	public double area(double chang, double kuan) {
    		// TODO Auto-generated method stub
    		double newArea = chang * kuan;  //长*宽
    		return newArea;
    	}

    	@Override //矩形的周长
    	public double girth(double chang, double kuan) {
    		// TODO Auto-generated method stub
    		double newGirth = 2*chang + 2*kuan; //2*长+2*宽
    		return newGirth;
    	}
    }


    package com.abstracttest;
    //调用方
    public class init {
    	public static void main(String[] args) {
    		// TODO Auto-generated method stub
    		Mould mould = new Rectangle();  		 //父类引用指向子类对象
    		double newArea = mould.area(150, 145.55);  //求面积
    		double newGirth = mould.girth(150, 145.55); //求周长
    		System.out.println("面积为：" + newArea);
    		System.out.println("周长为：" + newGirth);
    	}
    }

接口 **

1、概述

类是一种具体实现体，而接口定义了某一批类所需要遵守的规范，接口不关心这些类的内部数据，也不关心这些类里方法的实现细节，它只规定这些类里必须提供某些方法。
具有相同的功能，却不是同一个类的情况下，就可以使用接口

2、接口的定义

和类定义不同，定义接口不再使用class关键字，而是使用interface关键字。

3、接口定义的基本语法

1
2
3
4
5
public interface [abstract] 接口名 [extends 父接口1，父接口2 ...]   //可以多继承
{
    //零到多个常量定义 ...
    //零到多个抽象方法的定义 ...
}

接口就是用来被继承、被实现的，修饰符一般建议用public

注意：不能使用private和protected修饰接口

4、接口的定义

常量

接口中的属性是常量，即使定义时不添加， public static final修饰符，系统也会自动加上。

方法

接口中的方法只能是抽象方法，总是使用，即使定义时不添加public abstract修饰符，系统也会自动加上。

5、使用接口

（1）、一个类可以实现一个或者多个接口，实现接口使用implements关键字。java中一个类只能继承一个父类，是不够灵活的，通过实现多个接口可以做补充。

继承父类实现接口的语法为：

1
2
3
4
5
6
7
[修饰符] class 类名 extends 父类 implements 接口1，接口2 ...
{
    类体部分 //1、如果继承了抽象类，需要实现继承的抽象方法；
            //2、如果遵守了接口，要实现接口中的抽象方法。
            
            //**继承的抽象类中的方法和接口中的抽象方法都必须先实现。
}

注意：如果要继承父类，继承父类必须在实现接口之前。

根据下图实现接口实例：
java

实现如下：

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
【Telphone.java】
package com.phone;

//电话抽象类
public abstract class TelPhone {
	//具有发短信功能
	public abstract void sendMessage();
	//具有打电话功能
	public abstract void call();
}

【IPlayGame.java】
package com.phone;
//游戏机 接口
public abstract interface IPlayGame {
	
	//具有玩游戏的功能
	public abstract void playGame();
}


【CellPhone.java】
package com.phone;

//以前的手机
public class CellPhone extends TelPhone {

	@Override   //必须实现发短信功能
	public void sendMessage() {
		// TODO Auto-generated method stub
		System.out.println("老电话是具有发短信的功能");
	}

	@Override   //必须实现打电话功能
	public void call() {
		// TODO Auto-generated method stub
		System.out.println("老电话是具有打电话的功能");
	}
}

【SmartPhone.java】
package com.phone;

//现在的智能机
public class SmartPhone extends TelPhone implements IPlayGame {

	@Override //智能机具有发短信
	public void sendMessage() {
		// TODO Auto-generated method stub
		System.out.println("新电话是具有发短信的功能");
	}

	@Override //智能机具有打电话
	public void call() {
		// TODO Auto-generated method stub
		System.out.println("新电话是具有打电话的功能");
	}
	@Override  //智能机还具有玩游戏
	public void playGame() {
		System.out.println("新电话还具有游戏的功能");
	}
}

【init.java】 //出口-运行的地方
package com.phone;

public class init {

	public static void main(String[] args) {
		// TODO Auto-generated method stub
		TelPhone tel1 = new CellPhone();
		tel1.call();
		tel1.sendMessage();
		
		TelPhone tel2 = new SmartPhone();
		tel2.call();
		tel2.sendMessage();
		
		SmartPhone tel3 = new SmartPhone();
		tel3.playGame();
	}
}

（2）、接口在使用过程当中，还经常与匿名内部类配合使用

匿名内部类就是没有名字的内部类，多用于关注实现而不关注实现类的名称。

语法格式：

1
2
3
4
5
Interface i = new Interface(){
    public void method(){
        System.out.println("匿名内部类实现接口的方式");
    }
}

实例：

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
package com.phone;

public class init {

	public static void main(String[] args) {
		// TODO Auto-generated method stub
		TelPhone tel1 = new CellPhone();
		tel1.call();
		tel1.sendMessage();
		
		TelPhone tel2 = new SmartPhone();
		tel2.call();
		tel2.sendMessage();
		
		SmartPhone tel3 = new SmartPhone();
		tel3.playGame();
		
		//匿名内部类的使用 如下两种方式
		//语法第一种
		IPlayGame pg = new IPlayGame() {
			@Override
			public void playGame() {
				// TODO Auto-generated method stub
				System.out.println("这是匿名内部类的方式实现接口");
			}
		};
		pg.playGame();
		
		//语法第二种
		 new IPlayGame() {
			@Override
			public void playGame() {
				// TODO Auto-generated method stub
				System.out.println("这是匿名内部类的方式实现接口2");
			}
		}.playGame();
	}
}