Java基础知识-------面向对象（3）-中中

已于 2022-01-31 08:36:04 修改
阅读量183 收藏
点赞数
分类专栏： Java复习笔记 文章标签： java 开发语言 后端
于 2022-01-21 13:21:27 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_38361031/article/details/122569235
版权

Java基础知识-------面向对象（3）

1、接口

1.1接口的引入

说明 : 抽象类中可以有抽象方法, 但同时也可以包含非抽象方法.
在这里插入图片描述

定义：如果一个抽象类中所有的方法都是抽象的,则可以将这个类用另外一种方式来定义, 即接口.

新的改变

1.interface Guidable
2.{
3.    int YEARS = 2; 		// 训练时长 (常量)
4.    void blindGuiding();    // 导盲功能 (接口方法)
5.}

注意 :
接口中定义的方法和变量都包含一些默认修饰符.
接口中定义的方法默认使用 “public abstract” 来修饰,即抽象方法.
接口中变量默认使用 “public static final” 来修饰 .使用类名直接访问. 接口中的变量，都是常量。因此接口中的变量名一般都会全部大写。
默认修饰符可以省略不写。

1.interface Guidable{
2.   public static final int YEARS = 2;  	// 训练时长 
3.    public abstract void blindGuiding();    // 导盲功能
4.}

实现接口：由于接口中的方法都是抽象方法,因此不能通过实例化对象的方式来调用接口中的方法.此时需要定义一个类,并使用 implements 关键字实现接口中所有的方法.

注意 : 一个类在继承另一个类的同时还可以实现接口,此时 extends 关键字必须位于 implements 关键字之前.

1.// 定义一个 `Dog` 类,继承自 `Animal` 类, 并实现了 `Guidable` 接口
2.class Dog extends Animal implements Guidable 
3.{
4.	// 属性
5.
6.	// 行为
7.	void shout()
8.	{
9.		System.out.println("汪汪汪...");
10.	}
11.
12.	void eat()
13.	{
14.		System.out.println("跟我混,我骨头吃...");
15.	}
16.
17.	// 实现 Guidable 接口中的抽象方法
18.	public void blindGuiding()
19.	{
20.		System.out.println("经过"+Guidable.YEARS+"年的训练,Dog类具备了导盲的功能...");
21.	}
}

在这里插入图片描述
否则有可能报如下错误 :
在这里插入图片描述
类, 接口 之间产生关系：
1.类和类之间的关系是继承，使用extends关键字完成
2.类和接口之间的关系是实现，使用的 implements 关键字完成

1.2接口在代码中的体现

在这里插入图片描述
在这里插入图片描述
代码实现 :

1.class Demo 
2.{
3.	public static void main(String[] args) 
4.	{
5.		// 1. 创建一个 Dog 类的对象
6.		Dog d = new Dog();
7.		d.name = "哮天犬";
8.		d.shout();
9.		d.eat();
10.		d.run();
11.
12.		// 2. 创建一个 Cat 类的对象
13.		Cat c = new Cat();
14.		c.name = "波斯猫";
15.		c.shout();
16.		c.eat();
17.		c.run();
18.		
19.		// 3. 创建一个 Wolf 类的对象
20.		Wolf w = new Wolf();
21.		w.name = "灰太狼";
22.		w.shout();
23.		w.eat();
24.		w.run();
25.		
26.		// 接口与多态 :
27.		// 接口类型可以接收任何实现了该接口的实现类对象
28.		blind(d);
29.		blind(c);
30.
31.		drug(d);
32.		drug(w);
33.	}
34.	
35.	// 导盲
36.	public static void blind(Guidable g)
37.	{
38.		g.blindGuiding();
39.	}
40.	
41.	// 缉毒
42.	public static void drug(DrugDetectable d)
43.	{
44.		d.drugDetection();
45.	}
46.
47.}
48.
49.// 可导盲的接口
50.interface Guidable
51.{
52.	// 训练时长 (常量)
53.	int trainingYears = 2;
54.
55.	// 导盲功能 (接口方法)
56.	void blindGuiding();
57.}
58.
59./*
60.interface Guidable
61.{
62.	public static final int trainingYears = 2;
63.	public abstract void blindGuiding();
64.}
65.*/
66.
67.// 可缉毒的接口
68.interface DrugDetectable
69.{
70.	// 缉毒功能
71.	void drugDetection();
72.}
73.
74.
75.abstract class Animal
76.{
77.	String name;
78.	abstract void shout();
79.	abstract void eat();
80.	
81.	void run()
82.	{
83.		System.out.println(name + "正在疯狂裸奔...");
84.	}
85.}
86.
87.class Dog extends Animal implements Guidable, DrugDetectable
88.{
89.	void shout()
90.	{
91.		System.out.println("汪汪汪 ...");
92.	}
93.
94.	void eat()
95.	{
96.		System.out.println("跟我混, 有骨头吃...");
97.	}
98.
99.	// 实现 Guidable 接口中的方法
100.	public void blindGuiding()
101.	{
102.		System.out.println("经过" + Guidable.trainingYears + "年的训练," + name + "正在执行导盲的任务...");
103.	}
104.	
105.	// 实现 DrugDetectable 接口中的方法
106.	public void drugDetection()
107.	{
108.		System.out.println(name + "正在执行缉毒的功能...");
109.	}
110.}
111.
112.class Cat extends Animal implements Guidable
113.{
114.	void shout()
115.	{
116.		System.out.println("喵喵喵 ...");
117.	}
118.
119.	void eat()
120.	{
121.		System.out.println("跟我混, 有鱼吃...");
122.	}
123.	
124.	// 实现 Guidable 接口中的方法
125.	public void blindGuiding()
126.	{
127.		System.out.println("经过" + Guidable.trainingYears + "年的训练," + name + "正在执行导盲的任务...");
128.	}
129.
130.}
131.
132.class Wolf extends Animal implements DrugDetectable
133.{
134.	void shout()
135.	{
136.		System.out.println("嗷嗷嗷 ...");
137.	}
138.
139.	void eat()
140.	{
141.		System.out.println("跟我混, 有肉吃...");
142.	}
143.
144.	// 实现 DrugDetectable 接口中的方法
145.	public void drugDetection()
146.	{
147.		System.out.println(name + "正在执行缉毒的功能...");
148.	}
149.}

接口与多态 : 接口类型可以接收任何实现了该接口的实现类对象. （多态）

1.3 接口的特点

在这里插入图片描述

  1. 在程序中, 可以定义一个接口使用 extends 关键字去继承另一个接口. 同时也可继承多个接口,接口之间使用逗号隔开. 在Java中类只支持类的单继承，不支持类的多继承, 而Java对这个多继承进行改良，修改成了多实现。一个类在继承一个父类的同时，可以实现多个接口。一个类通过 implements 关键字实现接口时,可以实现多个接口,被实现的多个接口之间要用逗号隔开.

    1. 接口中的方法都是抽象的, 接口不能实例化对象. 接口不是类，它的出现仅仅是给描述这个事物体系增加额外的扩展功能。因此在接口中是没有构造方法的。也就是说接口是不能new对象的.
      在这里插入图片描述
      在这里插入图片描述
      . 当一个类实现接口时,如果这个类是抽象类,则实现接口中的部分方法即可.否则需要实现接口中的所有方法.
      一个类实现多个接口，这时由于接口中的方法都是抽象方法，只有子类实现了接口中的所有方法之后，最后我们需要创建实现类的对象，最后执行的方法，还是实现类中实现的方法，不管有多少个接口，即使它们的方法同名，由于都是抽象的，不会发生任何问题，最后运行还是实现类中方法。

总结:
类和类：继承关系，一个类只能继承一个父类。 单继承
类和接口：实现关系，一个类可以实现多个接口。 多实现
接口和接口：继承关系，一个接口可以继承多个接口。 多继承

类和类之间是继承关系，存在子类和父类的关系。子类需要覆盖父类的方法时，我们称为方法的重写。
类和接口之间是实现关系，实现接口的类，一般称为实现类，实现类中对接口中的方法进行重写的书写。这时称为实现类对接口的方法进行的实现.

1.class InterfaceDemo02 
2.{
3.	public static void main(String[] args) 
4.	{
5.		// 1. 创建一个 Auntie 类的对象
6.		// 调用方式一 面对的是 aunt 对象
7.		Auntie aunt = new Auntie();
8.		aunt.feedTheBaby();
9.		aunt.coaxTheBabyToSleep();
10.		aunt.changeTheDiaper();
11.		aunt.teachBabyToSing();
12.		aunt.laugh();
13.		
14.		System.out.println("---华丽的分割线---");
15.
16.		// 调用方式二  面对的是接口
17.		// 接口类型可以存放任何实现该接口类型对象的引用
18.		GoodBabySitter babySitter = new Auntie();
19.		babySitter.feedTheBaby();
20.		babySitter.coaxTheBabyToSleep();
21.		babySitter.changeTheDiaper();
22.
23.		// babySitter.teachBabyToSing(); 错误! 找不到方法.
24.		// BibySitter sitter = new BabySitter(); 错误! 不能实例化.
25.
26.		Singable s = new Auntie();
27.		s.teachBabyToSing();
28.		s.laugh();
29.		
30.		System.out.println("BabySitter.ID="+BabySitter.ID);
31.		System.out.println("Singable.ID="+Singable.ID);
32.	}
33.}
34.
35.// 定义一个 BabySitter 接口
36.interface BabySitter
37.{
38.	// 变量
39.	/* public static final */int ID = 10;
40.
41.	// 行为: 大笑
42.	void laugh();
43.
44.	// 行为: 喂宝宝吃东西
45.	void feedTheBaby();
46.
47.	// 行为: 哄宝宝睡觉
48.	void coaxTheBabyToSleep();
49.}
50.
51.// 定义一个 GoodBabySitter 接口 继承自 BabySitter 接口
52.interface GoodBabySitter extends BabySitter
53.{
54.	// 行为: 给宝宝换尿不湿
55.	void changeTheDiaper();
56.}
57.
58.// 定义一个 Singable 接口
59.interface Singable
60.{
61.	//变量(常量)
62.	int ID = 5;
63.
64.	// 方法: 大笑
65.	void laugh();
66.
67.	// 方法: 教宝宝唱儿歌
68.	void teachBabyToSing();
69.}
70.
71.// 定义一个 Auntie 类 实现了 GoodBabySitter, Singable 两个接口
72.class Auntie implements GoodBabySitter, Singable
73.{
74.	// 实现 GoodBabySitter 接口方法
75.	public void feedTheBaby()
76.	{
77.		System.out.println("保姆阿姨正在喂宝宝吃东西.");
78.	}
79.
80.	public void coaxTheBabyToSleep()
81.	{
82.		System.out.println("保姆阿姨正在哄宝宝睡觉.");
83.	}
84.
85.	public void changeTheDiaper()
86.	{
87.		System.out.println("保姆阿姨正在给宝宝换尿不湿.");
88.	}
89.
90.	// 实现 Singable 接口方法
91.	public void teachBabyToSing()
92.	{
93.		System.out.println("保姆阿姨正在教宝宝唱儿歌.");
94.	}
95.
96.	// 实现 laugh 方法
97.	public void laugh()
98.	{
99.		System.out.println("保姆阿姨正在和宝宝一起大笑.");
100.	}
101.}

在这里插入图片描述

1.4 抽象类和接口的区别

接口和抽象类都是描述事物的行为并且也可以定义常量和成员属性用于存储数据，并且描述的行为一般都是抽象的。需要子类或实现类对这些行为进行实现或重写。

1.抽象类和接口都可以有 abstract 方法，都不能实例化
2.抽象类中可以有非 abstract 方法.接口不可以.
3.接口中可以有常量,不能有变量,而抽象类中既可以有常量也可以有变量.
4.抽象类是继承体系的一员, 拥有类创建对象的构造方法, 但是接口中不存在 构造方法.

总结 : 抽象类依然是属于类继承体系中的一员。而接口则是类继承体系之外的事物描述.也可称为事物的扩展功能。

抽象类 : 表示一类事物的共性属性和行为. Is a
接口 : 对事物的行为进行功能的扩展. Like a

2. 面向对象 - 多态

2.1 多态的介绍

多态概述 :
在设计一个方法时,通常希望该方法具备一定的通用性.在同一个方法中,这种由于参数类型不同而导致执行效果各异的现象就是多态.
在Java中为了实现多态,允许使用一个父类类型的变量来引用一个子类类型的对象,根据被引用子类对象特征的不同,得到不同的运行结果.
多态性 : 多态的基础是继承. 类之间先有继承关系之后,才会产生多态的形式.

多态三要素：继承、重写和向上转型

程序中的多态 : 同一个行为,对于传入不同的 对象 而言.具有完全不同的表现形式.
生活中的多态: 当听到 cut 这个单词时, 理发师的行为是剪发, 演员的行为是停止表演, 医生就准备给你开刀了.

2.2 多态在代码中的体现

第一步 : 创建一个 理发师, 演员, 医生 类. 让类之间产生继承关系.

1.class Demo 
2.{
3.	public static void main(String[] args) 
4.	{
5.		// 1. 创建一个 `Barber` 类的对象
6.		Barber b = new Barber();
7.		b.name = "理发师";
8.
9.		// 2. 创建一个 `Actress` 类的对象
10.		Actress a = new Actress();
11.		a.name = "女演员";
12.
13.		// 3. 创建一个 `Doctor` 类的对象
14.		Doctor d = new Doctor();
15.		d.name = "女医生";
16.
17.		// 调用父类中共有的方法
18.		b.doSomething();
19.		a.doSomething();
20.		d.doSomething();
21.	}
22.
23.	// 功能: cut 行为
24.}
25.
26.// 创建一个共性的 `Person` 类
27.class Person
28.{
29.	// 属性
30.	String name;
31.	
32.	// 行为
33.	void doSomething()
34.	{
35.		System.out.println(name+"正在做 xxx ... ");
36.	}
37.}
38.
39.// 创建一个 `Barber` 类
40.class Barber extends Person
41.{
42.	// 属性
43.
44.	// 行为
45.}
46.
47.// 创建一个 `Actress` 类
48.class Actress extends Person
49.{
50.	// 属性
51.
52.	// 行为
53.}
54.
55.// 创建一个 `Doctor` 类
56.class Doctor extends Person
57.{
58.	// 属性
59.
60.	// 行为
61.}

在这里插入图片描述
第二步 : 添加一个 cut 功能, 然后让该方法接收不同的对象,执行不同的行为. 子类需重写 doSomething() 行为的实现体.

1.class Demo 
2.{
3.	public static void main(String[] args) 
4.	{
5.		// 1. 创建一个 `Barber` 类的对象
6.		Barber b = new Barber();
7.		b.name = "理发师";
8.
9.		// 2. 创建一个 `Actress` 类的对象
10.		Actress a = new Actress();
11.		a.name = "女演员";
12.
13.		// 3. 创建一个 `Doctor` 类的对象
14.		Doctor d = new Doctor();
15.		d.name = "女医生";
16.
17.		// 调用函数
18.		cut(b);
19.		cut(a);
20.		cut(d);
21.	}
22.
23.	// 功能: cut 行为
24.	// 理发师听到了 cut 需要做的事情
25.	public static void cut(Barber b)
26.	{
27.		b.doSomething();
28.	}
29.	
30.	// 女演员听到了 cut 需要做的事情
31.	public static void cut(Actress a)
32.	{
33.		a.doSomething();
34.	}
35.	
36.	// 医生听到了 cut 需要做的事情
37.	public static void cut(Doctor d)
38.	{
39.		d.doSomething();
40.	}
41.}
42.
43.// 创建一个共性的 `Person` 类
44.class Person
45.{
46.	// 属性
47.	String name;
48.	
49.	// 行为
50.	void doSomething()
51.	{
52.		System.out.println(name+"正在做 xxx ... ");
53.	}
54.}
56.// 创建一个 `Barber` 类
57.class Barber extends Person
58.{
59.	// 属性
60.
61.	// 行为
62.	void doSomething()
63.	{
64.		System.out.println(name+"正在给顾客认真细致的剪发. ");
65.	}
66.}
67.
68.// 创建一个 `Actress` 类
69.class Actress extends Person
70.{
71.	// 属性
72.
73.	// 行为
74.	void doSomething()
75.	{
76.		System.out.println(name+"立即停止的表演. ");
77.	}
78.}
79.
80.// 创建一个 `Doctor` 类
81.class Doctor extends Person
82.{
83.	// 属性
84.
85.	// 行为
86.	void doSomething()
87.	{
88.		System.out.println(name+"正在准备给患者开刀. ");
89.	}
90.}

在这里插入图片描述
第三步 : 使用多态语法简化 cut 方法的设计. 并使用多态语法简化子类对象的 引用接收.

1./*
2.	多态 : 同一个行为, 传入不同的对象, 具有完全不同的表现形式.
3.
4.	代码 : 父类的引用指向了子类的对象.
5.
6.
7.	使用场景1 :
8.	如果参数是一个父类类型, 我们传递一个子类对象, 可不可以?
9.	当然是可以的, 因为 `子类就是一个父类`. 
10.
11.	使用场景2 :
12.	创建了一个子类对象, 可以使用父类的引用进行接收, 程序编译不受影响.
13.*/
14.
15.class Demo 
16.{
17.	public static void main(String[] args) 
18.	{
19.		// 1. 创建一个 `Actress` 类的对象
20.		Person p = new Doctor();
21.		p.name = "女医生";
22.
23.		// 调用函数
24.		cut(p);
25.
26.		// Person   ->  Barber
27.	}
28.
29.	// 功能: cut 行为
30.	// `Person` 听到了 cut 需要做的事情
31.	public static void cut(Person p)
32.	{
33.		p.doSomething();
34.	}
35.}
36.
37.// 创建一个共性的 `Person` 类
38.class Person
39.{
40.	// 属性
41.	String name;
42.	
43.	// 行为
44.	void doSomething()
45.	{
46.		System.out.println(name+"正在做 xxx ... ");
47.	}
48.}
49.
50.// 创建一个 `Barber` 类
51.class Barber extends Person
52.{
53.	// 属性
54.
55.	// 行为
56.	void doSomething()
57.	{
58.		System.out.println(name+"正在给顾客认真细致的剪发. ");
59.	}
60.}
61.
62.// 创建一个 `Actress` 类
63.class Actress extends Person
64.{
65.	// 属性
66.
67.	// 行为
68.	void doSomething()
69.	{
70.		System.out.println(name+"立即停止的表演. ");
71.	}
72.}
73.
74.// 创建一个 `Doctor` 类
75.class Doctor extends Person
76.{
77.	// 属性
78.
79.	// 行为
80.	void doSomething()
81.	{
82.		System.out.println(name+"正在准备给患者开刀. ");
83.	}
84.}

多态语句在代码中的体现 : 父类的引用指向了子类的对象.
多态的使用场景 :
1.如果方法的参数是一个父类类型的, 我们传递一个子类对象, 当然是可以的, 因为子类就是一个父类.这样的设计简化了程序的编写.
2.程序中如果创建了一个子类对象, 我们可以使用父类的引用进行接收, 程序编译不受影响. 提高了代码的灵活性.

2.3 多态的弊端

1.class Demo 
2.{
3.	public static void main(String[] args) 
4.	{
5.		// 1. 创建一个 `Actress` 类的对象
6.		Person p = new Barber();
7.		p.name = "理发师";
8.
9.		// 调用函数
10.		cut(p);
11.
12.		// Person   ->  Barber
13.	}
14.
15.	// 功能: cut 行为
16.	// `Person` 听到了 cut 需要做的事情
17.	public static void cut(Person p)
18.	{
19.		p.doSomething();
20.		
21.		// 如何调用子类私有的方法 ?
22.		// 需要根据传入的不同对象, 进行不同对象的 `强制类型转换`---还是不行的。
23.		// Doctor d = (Doctor)p;  --不行的。
24.		// d.temptationOfUniforms();
25.
26.		// Actress a = (Actress)p;  --不行的。
27.		// a.beFamous();
28.
29.		Barber b = (Barber)p;  --可以
30.		b.chasingGirls();
31.	}
32.}
33.
34.// 创建一个共性的 `Person` 类
35.class Person
36.{
37.	// 属性
38.	String name;
39.	
40.	// 行为
41.	void doSomething()
42.	{
43.		System.out.println(name+"正在做 xxx ... ");
44.	}
45.}
46.
47.// 创建一个 `Barber` 类
48.class Barber extends Person
49.{
50.	// 属性
51.
52.	// 行为
53.	void doSomething()
54.	{
55.		System.out.println(name+"正在给顾客认真细致的剪发. ");
56.	}
57.
58.	// 特有行为 : 边工作边泡妞
59.	void chasingGirls()
60.	{
61.		System.out.println(name+"正在边工作边泡妞.");
62.	}
63.
64.}
65.
66.// 创建一个 `Actress` 类
67.class Actress extends Person
68.{
69.	// 属性
70.
71.	// 行为
72.	void doSomething()
73.	{
74.		System.out.println(name+"立即停止的表演. ");
75.	}
76.
77.	// 特有行为 : beFamous
78.	void beFamous()
79.	{
80.		System.out.println(name+"正走在成名的潜规则道路上.");
81.	}
82.}
83.
84.// 创建一个 `Doctor` 类
85.class Doctor extends Person
86.{
87.	// 属性
88.
89.	// 行为
90.	void doSomething()
91.	{
92.		System.out.println(name+"正在准备给患者开刀. ");
93.	}
94.
95.	// 特有行为 : tempationOfUniforms
96.	void temptationOfUniforms()
97.	{
98.		System.out.println(name+"正在手术台上对你进行制服诱惑.");
99.	}
100.}

多态的弊端：不能使用父类对象调用子类中的成员变量和特有方法。

在多态中的类型转换问题 :
1.隐式的类型提升.只要有多态就会发生类型提升. (向上转型) Person p = new Doctor();
2.强制类型转换. 将父类类型转成子类类型. (向下转型) Doctor d = (Doctor)p;

说明 : 向下转型,目的就是为了调用子类特有的方法.
格式 : 子类类型 子类对象名 = (子类类型)父类对象名; Doctor d = (Doctor)p;

说明 : 如果调用的是父类中的共性方法,无需进行类型转换. 子类如果有重写,调用子类该方法,子类如果没有进行重写,则调用父类该方法. 需要注意的是,此时不能通过父类变量去调用子类中的 子类特有方法.

什么时候使用向下转型 :
只要在程序中我们需要使用子类的特有属性或行为的时候,才会使用向下转型.
2.4 向下转型的风险

问题 : 向下转型有风险,使用需谨慎. 在Java中要使用向下转型,必须先做类型的判断,然后再转型.Java中的类型判断,需要使用关键字 instanceof.
instanceof 运算符是双元运算符, 左面的操作是一个对象,右面是一个类.当左面的对象是右面的类或子类创建的对象时,该运算符运算的结果是true,否则是false.

1." 判断格式："
2.    if（父类引用变量名  instanceOf  子类对象所属的类名）  对象 instanceof 类型
3.    {
4.        进行转换。
5.    }

一定要判断,防止类型转换异常的发生. 如果程序发生 classCastException, 一定是将不是这种类型的对象转成了该类型对象,发生类型转换异常.

1./*
2.	多态 : 同一个行为, 传入不同的对象, 具有完全不同的表现形式.
3.
4.	代码 : 父类的引用指向了子类的对象.
5.
6.	使用场景1 :
7.	如果参数是一个父类类型, 我们传递一个子类对象, 可不可以?
8.	当然是可以的, 因为 `子类就是一个父类`. 
9.
10.	使用场景2 :
11.	创建了一个子类对象, 可以使用父类的引用进行接收, 程序编译不受影响.
13.	向下转型有风险, 实现需谨慎. 在Java中要使用向下转型,必须先做类型的判断,然后在转型.
     	格式:  if（对象 instanceof 类名）{}
    	说明 : instanceof是一个双元运算符,左边的操作是一个对象.
      右面的操作是一个类,当左边的对象是右边类的或者子类创建的对象时,
     该运算符返回的结果是 true, 否则 false.
*/
22.class Demo 
23.{
24.	public static void main(String[] args) 
25.	{
26.		// 1. 创建一个 `Actress` 类的对象
27.		Person p = new Barber();
28.		p.name = "理发师";
29.
30.		// 调用函数
31.		cut(p);
32.	}
33.
34.	// 功能: cut 行为
35.	// `Person` 听到了 cut 需要做的事情
36.	public static void cut(Person p)
37.	{
38.		p.doSomething();
39.		
40.		// 如何调用子类私有的方法 ?
41.		// 需要根据传入的不同对象, 进行不同对象的 `强制类型转换`
42.		if (p instanceof Barber)
43.		{
44.			Barber b = (Barber)p;
45.			b.chasingGirls();
46.		} 
47.		else if (p instanceof Actress)
48.		{
49.			Actress a = (Actress)p;
50.			a.beFamous();
51.		}
52.		else if (p instanceof Doctor)
53.		{
54.			Doctor d = (Doctor)p;
55.			d.temptationOfUniforms();
56.		}
57.	}
58.}
59.
60.// 创建一个共性的 `Person` 类
61.class Person
62.{
63.	// 属性
64.	String name;
65.	
66.	// 行为
67.	void doSomething()
68.	{
69.		System.out.println(name+"正在做 xxx ... ");
70.	}
71.}
72.
73.// 创建一个 `Barber` 类
74.class Barber extends Person
75.{
76.	// 属性
77.
78.	// 行为
79.	void doSomething()
80.	{
81.		System.out.println(name+"正在给顾客认真细致的剪发. ");
82.	}
83.
84.	// 特有行为 : 边工作边泡妞
85.	void chasingGirls()
86.	{
87.		System.out.println(name+"正在边工作变泡妞.");
88.	}
89.
90.}
91.
92.// 创建一个 `Actress` 类
93.class Actress extends Person
94.{
95.	// 属性
96.
97.	// 行为
98.	void doSomething()
99.	{
100.		System.out.println(name+"立即停止的表演. ");
101.	}
102.
103.	// 特有行为 : beFamous
104.	void beFamous()
105.	{
106.		System.out.println(name+"正走在成名的潜规则道路上.");
107.	}
108.}
109.
110.// 创建一个 `Doctor` 类
111.class Doctor extends Person
112.{
113.	// 属性
114.
115.	// 行为
116.	void doSomething()
117.	{
118.		System.out.println(name+"正在准备给患者开刀. ");
119.	}
120.
121.	// 特有行为 : tempationOfUniforms
122.	void temptationOfUniforms()
123.	{
124.		System.out.println(name+"正在手术台上对你进行制服诱惑.");
125.	}
126.}

笔记本电脑案例

案例介绍

定义USB接口（具备开启功能、关闭功能），笔记本要使用USB设备，即笔记本在生产时需要预留可以插入USB设备的USB接口，即就是笔记本具备使用USB设备的功能，但具体是什么USB设备，笔记本并不关心，只要符合USB规格的设备都可以。鼠标和键盘要想能在电脑上使用，那么鼠标和键盘也必须遵守USB规范，不然鼠标和键盘的生产出来无法使用
进行描述笔记本类，实现笔记本使用USB鼠标、USB键盘
1.USB接口，包含开启功能、关闭功能
2.笔记本类，包含运行功能、关机功能、使用USB设备功能
3.鼠标类，要符合USB接口
4.键盘类，要符合USB接口
案例需求分析
阶段一：
使用笔记本，笔记本有运行功能，需要笔记本对象来运行这个功能
阶段二：
想使用一个鼠标，又有一个功能使用鼠标，并多了一个鼠标对象。
阶段三：
还想使用一个键盘 ，又要多一个功能和一个对象
问题：每多一个功能就需要在笔记本对象中定义一个方法，不爽，程序扩展性极差。
降低鼠标、键盘等外围设备和笔记本电脑的耦合性。
实现代码步骤
5.定义鼠标、键盘，笔记本三者之间应该遵守的规则

interface USB {
	void open();// 开启功能
	void close();// 关闭功能
}

6.鼠标实现USB规则

class Mouse implements USB {
	publicvoid open() {
		System.out.println("鼠标开启");
	}

	publicvoid close() {
		System.out.println("鼠标关闭");
	}
}

7.键盘实现USB规则

class KeyBoard implements USB {
	publicvoid open() {
		System.out.println("键盘开启");
	}

	publicvoid close() {
		System.out.println("键盘关闭");
	}
}

8.定义笔记本

 class NoteBook {
	// 笔记本开启运行功能
	publicvoid run() {
		System.out.println("笔记本运行");
	}
	// 笔记本使用usb设备，这时当笔记本对象调用这个功能时，必须给其传递一个符合USB规则的USB设备
	publicvoid useUSB(USB usb) {
		// 判断是否有USB设备
		if (usb != null) {
			usb.open();
			usb.close();
		}
	}
	publicvoid shutDown() {
		System.out.println("笔记本关闭");
	}
}

9.测试方法

public class Test {
	publicstaticvoid main(String[] args) {
		// 创建笔记本实体对象
		NoteBook nb = new NoteBook();
		// 笔记本开启
		nb.run();

		// 创建鼠标实体对象
		Mouse m = new Mouse();
		// 笔记本使用鼠标
		nb.useUSB(m);

// 创建键盘实体对象
		KeyBoard kb = new KeyBoard();
		// 笔记本使用键盘
		nb.useUSB(kb);

		// 笔记本关闭
		nb.shutDown();
	}
}
Learning Birdie
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
吴-Ritt算法 python实现
03-04
研究生期间学过计算机代数的这门课，书中需要实现的吴-Ritt算法，这里面可以参考一下。注意根据数据结构将输入多项式手动整理成代码中中的嵌套列表形式。本人已经亲自测试多个例子，与maple软件算的结果一样。
【JavaSE专栏63】多态，父类引用子类的对象，面向对象编程中的重要概念
Designer 小郑的技术博客
08-01 1114
本文讲解了 Java 中面向对象多态的概念及语法，并给出了样例代码。多态是面向对象编程中的一个重要概念，它允许使用父类的引用变量来引用子类的对象，实现对不同子类对象的统一处理。
java多态性，父类引用指向子类对象
weixin_33749131的博客
09-05 325
父类引用指向子类对象指的是： 例如父类Animal，子类Cat,Dog。其中Animal可以是类也可以是接口，Cat和Dog是继承或实现Animal的子类。 Animal animal = new Cat(); 即声明的是父类，实际指向的是子类的一个对象。 那我们从内存角度来理解试试. 假设现在有一个父类Father,它里面的变量需要占用1M内存. 有一个它的子类S...
【Java】面向对象的三大特性之一------多态
qq_43669007的博客
10-14 213
1.多态 1.1多态的产生 程序员在开发过程中，需要在代码中编写很多方法，其次，很多方法的形式差不多，那么到最后调用方法时就会很容易出错， 看下面的例子： public class Test{ int x; int y; int z; void print1(int x){ System.out.println(x); } ...
多态性
weixin_33862041的博客
02-23 40
多态性： 当理发师听到"cut"的时候会开始剪头发演员听到"cut"的时候会停止表演医生听到"cut"的时候会在病人身上切道口子 转载于:https://www.cnblogs.com/exodusxy/archive/2012/02/23/2364604.html...
D-Link DIR-600N 固件 语言包 刷机 中文
01-27
D-Link DIR-600N 这个型号的路由器毛病太多，官网除名了，所以固件语言包官网找不到了，本人在虚拟机中中了毒才下载到，分享给大家。 固件NA,NB不通用，语言包NA,NB是通用的。
jfreechart-1.0.13-demo源码
10-15
使用jfreechart的一定要用,本是收费的,查看官方下的jfreechart-1.0.13-demo.jar效果,对就的源码就是这了.
rust-lock-bug-detector:静态检测MIR上的双锁和冲突锁错误
04-09
这项工作是对我们详细研究Rust的后续工作，该研究在PLDI'20中中的问题。 我很荣幸能与Chen Yilun Chen共同发表第一作者，并且能够与具有远见，知识渊博，勤奋工作的Song Linhai教授和Zhang Yiying进行合作。 在本文...
2000-2020年省级营商环境
04-13
2000-2020年省级营商环境的相关研究中中，“政策环境指数”的原始数据及测算 一、数据来源与样本量 1. 数据来源：国家统计局 2. 样本量：2000-20 20年31个省份的651个样本 二、原始数据及处理方式 在“原始数据”的...
链表刷题集
yajunjiao的专栏
04-30 813
本文主要列举了一些刷的题，不多，有那么几道，也建议各位去建立自己的刷题集。积少成多。
Spring Cloud——LoadBalancer
????
05-01 1801
这里只是简单的讲解了一下LoadBalancer如何使用，因为实际上我们使用的不是很多，主要还是使用OpenFeign。
d15(136-148)-勇敢开始Java，咖啡拯救人生
m0_73459387的博客
04-28 1349
对象哈希值的特点：同一个对象调用hashCode()返回的哈希值相同；HashMap的键依赖hashCode方法和equals方法保证键的唯一，存储自定义类型的对象时，重写这两个方法。实际上，Set系列集合的底层就是基于Map实现的，只是Set集合中的元素要键数据，不要值数据。当12个位置都占满时就会扩容，大约扩容为原来的二倍，再把原数组数据转移到新数组。使用迭代器遍历集合时，又同时在删除集合中的数据，程序就会出现并发修改异常的错误。基于哈希表实现，每个键值对额外多了一个双链表的机制，记录元素顺序（保证。
Java解决最长公共前缀
无人罪的博客
04-28 653
编写一个函数来查找字符串数组中的最长公共前缀。如果不存在公共前缀，返回空字符串""。
【一步一步了解Java系列】：探索Java基本类型与C语言的区别
2302_81249757的博客
04-29 1160
​​喜欢的一句话： 常常会回顾努力的自己，所以要为自己的努力留下足迹。作者：小闭。
Spring cloud原理详解
qq_33449977的博客
04-28 756
想象一下，你开了一家餐馆，一开始只卖汉堡，后来生意火了，你又增加了炸鸡、披萨、冰淇淋各种摊位，每个摊位就是一个微服务，它们各自独立工作，但又得相互配合。有时候，某个服务可能太忙了，电话老打不通，这时候Spring Cloud还有个叫Hystrix的断路器，它会说：“嘿，别打了，那边线路忙，我给你个备用方案或者告诉你稍后再试。至于餐馆运营情况，Spring Cloud Sleuth和Zipkin这些工具，就像监控摄像头，记录服务间的每一次交互，方便你查看哪里出了问题，优化服务流程。
Nacos 配置中心实例分析实践
最新发布
m0_73557631的博客
05-03 979
​ 浏览器: http://localhost:5000/nacos/config/ip。先创建e-commerce-nacos-config-client5000 模块。​ 启动e-commerce-nacos-config-client5000。​ 启动Nacos Server。
软件工程毕业设计选题100例
HUXINY的博客
05-02 1083
学长搜集分享最新的软件工程业专业毕设选题，难度适中，适合作为毕业设计，大家参考。相对容易工作量达标题目新颖。
公考学习平台|基于SprinBoot+vue的公考学习平台(源码+数据库+文档)
weixin_66413741的博客
04-30 1289
本共享汽车管理系统有管理员和用户。管理员功能有个人中心，用户管理，投放地区管理，汽车信息管理，汽车投放管理，汽车入库管理，使用订单管理，汽车归还管理。用户可以在注册登录，可以对汽车进行使用产生订单，还可以归还。因而具有一定的实用性。本站是一个B/S模式系统，采用Spring Boot框架，MYSQL数据库设计开发，充分保证系统的稳定性。系统具有界面清晰、操作简单，功能齐全的特点，使得共享汽车管理系统管理工作系统化、规范化。
sv中中grep -r 和grep -n的作用
04-08
在SV（SystemVerilog）中，grep命令是用于在文件中搜索指定模式的工具。grep -r和grep -n是grep命令的两个常用选项。 1. grep -r：该选项用于递归地搜索指定目录下的所有文件，并输出包含指定模式的行。...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值