2017年3月29号课堂笔记

2017年3月29号星期三空气质量：中度雾霾~重度雾霾

内容：多态，接口，多态的一道面试题

一、多态（文档讲解）

* 多态：
* 同一个操作，由于条件的不同，产生不同的结果！
* 同一个引用类型，使用不同的实例而执行不同的结果！
*
* 多态的两种形式：
* 01.编译时的多态（方法重载）
* feed(Dog dog)
* feed(Cat cat)
* feed(Penguin penguin)
* 02.运行时的多态
* 程序在运行期间，根据不同的参数类型，从而执行不同的对象方法！
*
* 多态存在的必要条件：
* 01.有继承！
* 02.有重写！
* 03.父类的引用指向了子类的对象！

* 给小宠物喂食
01.父类对象作为参数
master.feed(dog); 父类的引用指向了子类的对象！
master.feed(penguin);
*/

/**
* 出售宠物
* 02.返回值是父类类型，可以用子类类型接收

*Pet pet=new Dog();
* 小狗是宠物--->OK!
* dog = master.salePet(dog);
* 宠物是小狗？？？--->
* dog = (Dog) master.salePet(dog);--->正确
* 向下转型:
* 把父类类型转换成其对应的子类类型！
* dog = (Dog) master.salePet(dog);

二、多态（图示）

三、多态Demo

1、老师代码：

1）狗狗实体类：

package cn.bdqn.bean;

/**
*狗狗的实体类
*/
public class Dog extends Pet {

private String strain; // 品种

// 无参构造方法
public Dog() {
}

// 带参构造函数
public Dog(String name, String strain, int health, int love) {
this.strain = strain;
}

public void showInfo() {
super.showInfo(); // 调用父类的方法
System.out.println("品种是：" + this.strain);
}

public String getStrain() {
return strain;
}

public void setStrain(String strain) {
this.strain = strain;
}

/**
* 吃食的方法
*/
public void eat() {
System.out.println("小狗狗在吃骨头");
}

// 出售宠物
@Override
public Dog salePet() {
System.out.println("小狗狗被卖掉了！");
return this;
}

// 小狗玩耍的方法
public void dogPlay() {
System.out.println("小狗玩耍的方法");
}

}

2）企鹅实体类：

package cn.bdqn.bean;

/**
*企鹅的实体类
*/
public class Penguin extends Pet {
public String sex; // 性别

// 带参构造
public Penguin(String name, int health, int love, String sex) {
System.out.println("Penguin的带参构造");
this.sex = sex;
}

/**
* 重写父类的方法
*/
@Override
public void showInfo() {
super.showInfo();
System.out.println("性别是：" + sex);
}

// 无参构造
public Penguin() {
}

/**
* 吃食的方法
*/
public void eat() {
System.out.println("企鹅在吃鱼");
}

// 出售的方法
@Override
public Penguin salePet() {
System.out.println("企鹅被卖掉了！");
return this;
}

// 企鹅玩耍的方法
public void penguinPlay() {
System.out.println("企鹅玩耍的方法");
}

}

3）宠物类（父类）：

package cn.bdqn.bean;

//宠物类（父类）
public abstract class Pet {
// 成员变量子类共有的属性
private String name; // 姓名
private int health;// 健康值
private int love;// 亲密度

// 父类的无参构造
public Pet() {
}

// 带参构造
public Pet(String name, int health, int love) {
this.name = name;
this.health = health;
this.love = love;
}

/**
* 输出宠物的信息所有宠物共享的！
*/
public void showInfo() {
System.out.println("姓名:" + this.name);
System.out.println("健康值:" + this.health);
System.out.println("亲密度:" + this.love);
}

// 对应的set和get方法
public String getName() {
return name;
}

public void setName(String name) {
this.name = name;
}

public int getHealth() {
return health;
}

public void setHealth(int health) {
this.health = health;
}

public int getLove() {
return love;
}

public void setLove(int love) {
this.love = love;
}

/**
* 有必要写方法体吗？
* 因为每个宠物的吃饭方法都是不一致的！
*/
public abstract void eat();

// 宠物被卖掉的方法
public abstract Pet salePet();

}

4）所有宠物的主人类：

package cn.bdqn.bean;

/**
* 所有宠物的主人类
*/
public class Master {

/**
* 主人喂养着两个宠物
* 01.给小狗狗喂食

public void feed(Dog dog) {
dog.eat();
}

02.给企鹅喂食
public void feed(Penguin penguin) {
penguin.eat();
}

主人可以养许多的宠物，每个宠物吃食的方法都是不一样的！
那么我们就必须在这个主人类中书写N个喂食的方法！
这样很麻烦！
怎么解决这个问题？
*/

/**
* 多态的实现：
* 01.父类对象作为参数
*/
public void feed(Pet pet) {
pet.eat();
}

/**
* 02.返回值是父类类型
* 主人不开心，卖宠物！
* 传过来一个宠物，之后卖掉
*/
public Pet salePet(Pet pet) {
pet.salePet();
return pet;
}

/**
* 模拟主人与宠物进行玩耍
* 01.先在我们的pet中创建公共的play方法
* 02.两个子类中去重写
*
* 如果子类中的方法名不一致了？子类中有特有的方法？
* 什么是特有的方法？父类中没有的！
* 就像根据传入实例的不同，调用不同的对象方法！
* 这时候我们怎么来区分是哪个宠物？
*/
public void play(Pet pet) {
if (pet instanceof Dog) {
// 需要把pet向下转型为Dog
Dog dog = (Dog) pet;
dog.dogPlay();
}
if (pet instanceof Penguin) {
// 需要把pet向下转型为Penguin
Penguin penguin = (Penguin) pet;
penguin.penguinPlay();
}
}

}

5）测试类：

package cn.bdqn.test;

//测试类
import cn.bdqn.bean.Dog;
import cn.bdqn.bean.Master;
import cn.bdqn.bean.Penguin;

/**
*
* 多态：
* 同一个操作，由于条件的不同，产生不同的结果！
* 同一个引用类型，使用不同的实例而执行不同的结果！
*
* 多态的两种形式：
* 01.编译时的多态（方法重载）
* feed(Dog dog)
* feed(Cat cat)
* feed(Penguin penguin)
* 02.运行时的多态
* 程序在运行期间，根据不同的参数类型，从而执行不同的对象方法！
*
* 多态存在的必要条件：
* 01.有继承！
* 02.有重写！
* 03.父类的引用指向了子类的对象！
*/
public class PetTest {

public static void main(String[] args) {
// 实现主人给两个宠物喂食
Dog dog = new Dog();
Penguin penguin = new Penguin();
// 创建主人实例
Master master = new Master();
/**
* 给小宠物喂食
01.父类对象作为参数
master.feed(dog); 父类的引用指向了子类的对象！
master.feed(penguin);
*/

/**
* 出售宠物
* 02.返回值是父类类型，可以用子类类型接收
* 小狗是宠物
* dog = master.salePet(dog);
* 宠物是小狗？？？
dog = (Dog) master.salePet(dog);
* 向下转型
* 把父类类型转换成其对应的子类类型！
* dog = (Dog) master.salePet(dog);
*/

// 玩耍的方法
master.play(dog);

}

四、多态的一道面试题Demo（难点，梳理清楚）

老师代码：

1、类A：

package exam;

public class A {

// 现在这两个方法是重载
public String show(D d) {
return "A and D";
}

public String show(A a) {
return "A and A";
}
}

2、类B：

package exam;

public class B extends A { // 继承了 A

// 现在这两个方法是重载
public String show(B b) {
return "B and B";
}

// 重写了A的方法
public String show(A a) {
return "B and A";
}
}

3、类C:

package exam;

public class C extends B {

}

4、类D:

package exam;

public class D extends B {

}

5、测试类：

package exam;

public class TestABCD {

public static void main(String[] args) {
A a1 = new A();
A a2 = new B(); // 父类的引用指向了子类的对象
B b = new B();
C c = new C();
D d = new D();

// A and A System.out.println(a1.show(b));
// A and A System.out.println(a1.show(c));
// A and D System.out.println(a1.show(d));
// B and A System.out.println(a2.show(b)); 子类中有对应的方法执行子类重写之后的方法
// B and A System.out.println(a2.show(c)); 子类中没有对应的方法执行父类的方法
// A and D System.out.println(a2.show(d));
// B and B System.out.println(b.show(b));
// B and B System.out.println(b.show(c));//子类和父类都没有完全对应c的方法，先继承到父类b传参（自己理解）
// A and D System.out.println(b.show(d)); //子类中没有对应的方法，直接去父类中查询
}

}

五、接口（文档讲解）：

* java中不支持多继承！
* 接口来解决这个问题！
*
* interface:接口！本身就是一个抽象类！
* 接口中就是提供了某种能力，但是它不关心能力的实现！
* 接口的特点：
* 01.接口中所有的方法都是 public abstract修饰的！不允许出现方法体
* 02.接口的实现类必须去实现接口中所有的方法，除非实现类是抽象类或者接口！
* 03.接口中所有的属性都是 final static修饰的静态常量，必须赋予初始值！
* 04.接口可以实现接口，只不过实现的方式是用extends
* Fly extends Fly2, Fly3 =====》多实现并不是多继承！
* 05.接口不能实例化！也不能有构造方法！
*
* 常用的接口方式：
* 01.接口什么都不定义！！！
* 02.接口中定义了很多静态常量！
* 03.接口中定义了很多方法！
*
*
* 对象与类的关系是 is a
* 对象与接口的关系是 has a

六、接口（图示）

七、接口Demo01（小鸟飞行）

老师代码：

1、Bird类继承了宠物类实现了 Fly接口中的功能：

package cn.bdqn.bean;

import cn.bdqn.dao.Fly;

/**
*Bird继承了宠物类实现了 Fly接口中的功能！
*/
public class Bird extends Pet implements Fly {

@Override
public void eat() {
System.out.println("小鸟在吃虫子");
}

// 实现了 Fly接口中的功能！
@Override
public void fly() {
System.out.println("小鸟在飞行");
}

}

2、宠物类（父类）：

package cn.bdqn.bean;

//宠物类（父类）
public abstract class Pet {
// 成员变量子类共有的属性
private String name; // 姓名
private int health;// 健康值
private int love;// 亲密度

// 父类的无参构造
public Pet() {
}

// 带参构造
public Pet(String name, int health, int love) {
this.name = name;
this.health = health;
this.love = love;
}

// 对应的set和get方法
public String getName() {
return name;
}

public void setName(String name) {
this.name = name;
}

public int getHealth() {
return health;
}

public void setHealth(int health) {
this.health = health;
}

public int getLove() {
return love;
}

public void setLove(int love) {
this.love = love;
}

public abstract void eat();

}

3、接口fly：

package cn.bdqn.dao;

/**
*
* java中不支持多继承！
* 接口来解决这个问题！
*
* interface:接口！本身就是一个抽象类！
* 接口中就是提供了某种能力，但是它不关心能力的实现！
* 接口的特点：
* 01.接口中所有的方法都是 public abstract修饰的！不允许出现方法体
* 02.接口的实现类必须去实现接口中所有的方法，除非实现类是抽象类或者接口！
* 03.接口中所有的属性都是 final static修饰的静态常量，必须赋予初始值！
* 04.接口可以实现接口，只不过实现的方式是用extends
* Fly extends Fly2, Fly3 =====》多实现并不是多继承！
* 05.接口不能实例化！也不能有构造方法！
*
* 常用的接口方式：
* 01.接口什么都不定义！！！
* 02.接口中定义了很多静态常量！
* 03.接口中定义了很多方法！
*
*
* 对象与类的关系是 is a
* 对象与接口的关系是 has a
*
*/
// public interface Fly extends Fly2, Fly3 {
public interface Fly {
/**
* 能力
*/
void fly();

}

4、接口fly2：

package cn.bdqn.dao;

public interface Fly2 {

void fly2();
}

5、接口fly3：

package cn.bdqn.dao;

public interface Fly3 {

void fly3();
}

6、测试类：

package cn.bdqn.test;

import cn.bdqn.bean.Bird;

public class BirdTest {

public static void main(String[] args) {
Bird bird = new Bird();
bird.eat();
bird.fly(); // 功能

}

八、接口Demo02（防盗门）

老师代码：

1、门的抽象类（开门，关门两个方法）：

package cn.bdqn.bean;

/**
* 门
* 不同的门开门关门的方式不同
* 我们不能把功能写死
*
* 门是抽象类
* 卷帘门
* 木门
* 铁门
* 玻璃门
*/
public abstract class Door {
// 开门
public abstract void open();

// 关门
public abstract void close();

}

2、防盗的接口（上锁，开锁两个方法）：

package cn.bdqn.dao;

/**
* 接口只是提供了某些功能
*
* 防盗门具有防盗的功能
* 防盗窗具有防盗的功能
*
* 上锁和开锁
*/

public interface LockInterface {

// 上锁
void lockUp();

// 开锁
void lockDown();
}

3、防盗门类（继承门，实现防盗接口）：

package cn.bdqn.bean;

import cn.bdqn.dao.LockInterface;

/**
*
*防盗门首先是一个门然后具有防盗的功能
*/
public class PanDoor extends Door implements LockInterface {

@Override
public void lockUp() {
System.out.println("门被锁上了");
}

@Override
public void lockDown() {
System.out.println("锁被打开了");
}

@Override
public void open() {
System.out.println("门被打开了");
}

@Override
public void close() {
System.out.println("门被关上了");
}

}

4、测试类：

package cn.bdqn.test;

import cn.bdqn.bean.PanDoor;

public class TestDoor {
public static void main(String[] args) {

PanDoor door = new PanDoor();
door.lockDown();
door.open();
door.close();
door.lockUp();
}

}

九、作业

1、视频至少看完高级第一节（集合），最好能看完实用类

2、租赁汽车项目下次课前交到局域网

3、做题

十、老师辛苦了！

posted @ 2017-03-29 14:46 不抽烟的香吉士阅读(221) 评论(0) 编辑收藏举报

指间灵动，快码加编

刷新页面返回顶部

不抽烟的香吉士

You can either travel or read,but either your body or soul must be on the way.

2017年3月29号课堂笔记

公告