黑马Java第十一讲笔记—多态抽象类接口

黑马Java第十一讲笔记—多态抽象类接口

🎨 个人介绍

👉大家好，我是：知识的搬运工旺仔

👉认真分享技术，记录学习过程的点滴，如果我的分享能为你带来帮助，请支持我奥🍻

👉你的支持，是我每天更新的动力。

👉赞点：👍 留言：✍ 收藏：⭐

👉个人格言：想法一步一步的落实，才是你我前进最佳选择。

黑马Java第十一讲笔记—多态&抽象类&接口

• 1. 多态
• • 1.1 多态的概述
  • 1.2 多态中的成员访问特点
  • 1.3 多态的好处与弊端
  • 1.4 多态中的转型
  • 1.5 多态的案例
• 2. 抽象类
• • 2.1 抽象类的 概述
  • 2.2 抽象类的特点
  • 2.3 抽象类的成员特点
  • 2.4 抽象类的案例
• 3. 接口
• • 3.1 接口的概述
  • 3.2 接口的特点
  • 3.3 接口的成员特点
  • 3.4 接口的案例
  • 3.5 类和接口的关系
  • 3.6 抽象类和接口的区别
• 4. 综合案例
• • 4.1 案例需求
  • 4.2 代码实现

1. 多态

1.1 多态的概述

1 ）什么是多态

1. 同一个对象，在不同时刻表现出来的不同形态

2 ）多态的前提

1. 要有继承或实现关系
2. 要有方法重写
3. 要有父类引用指向子类对象

1.2 多态中的成员访问特点

1 ）成员访问特点

1. 成员变量：编译看父类，运行看父类
2. 成员方法：编译看父类，运行看子类

2 ）代码实例

1. 动物类

public class Animal {public int age = 40;public void eat() {System.out.println("动物吃东西");}
}

2. 猫类

public class Cat extends Animal {public int age = 20;public int weight = 10;@Override public void eat() {System.out.println("猫吃鱼");}public void playGame()  {System.out.prinln("猫捉鱼");}
}

3. 测试类

public static AnimalDemo {public static void main(String[] args) {//有父类引用指向子类对象Animal a = new Cat();System.out.println(a.age);// 下面这个使用会报错，因为父类引用指向子类，只能使用父类的所有成员变量，子类新增的不能使用System.out.println(a.weight); a.eat();// 这个方法会报错，因为父类引用指向子类，只能使用父类的所有方法，子类新增的不能使用a.playGame();}
}

1.3 多态的好处与弊端

1 ）好处

1. 提高程序的扩展性。定义方法时候，使用父类型作为参数，使用具体的子类型参与操作

2 ）弊端

1. 不能使用子类特有成员

1.4 多态中的转型

1 ）向上转型

1. 父类引用指向子类对象是向上转型

2 ）向下转型

1. 格式： 子类型 对象名 = (子类型) 父类引用;

3 ）代码演示

1. 动物类

public class Animal {public void eat() {System.out.println("动物吃东西");}
}

2. 猫类

public class Cat extends Animal {@Overridepublic void eat() {System.out.println("猫吃鱼");}public void playGame() {System.out.prinln("猫捉迷藏");}
}

3. 测试类

public class AnimalDemo {public static void main(String[] args) {// 上转型Animal a = new Cat();a.eat();// 边下的方法会报错a.palyGame();//向下转型Cat c = (Cat) a;// 下边的da.eat();a.palyGame();}
}

1.5 多态的案例

1 ）案例需求

请采用多态的思想实现猫和狗的案例，并在测试类中进行测试

2 ）代码实现

1. 动物实现类

public class Animal {private String name;private int age;public Animal() {}public Animal(String name , int age) {this.name = name;this,age = age;}public String getName() {return name;}public void setName() {this.name = name;}public int getAge() {return age;}public void eat() {this.age = age;}public void est() {System.out.println("动物吃东西");}
}

2. 猫类

public class Cat extends Animal {public Cat() {}public Cat(String name,int age) {super(name,age);}
​@Overridepublic void eat() {System.println.out("猫吃鱼");}
}

3. 狗类

public class Dog extends Animal {public Dog() {}public Dog (String name,int age) {super(name,age);}@Overridepublic void eat() {System.out.println("狗吃骨头");}
}

4. 测试类

public class AnimalDemo {public static void main(String[] args) {//创建猫类对象进行测试Animal a = new Cat();a.setName("加菲");a.setAge(5);System.out.Name + "," + a.getAge());e.eat();a = new Cat("加菲",5);System.out.Name() + "," + a.getAge());a.eat();}
}

2. 抽象类

2.1 抽象类的 概述

1. 当我们在做子类共性功能抽取时，有些方法在父类中并没有具体的体现，这个时候就需要抽象类了！
2. 在Java中，一个没有方法体的方法应该定义为抽象方法，而类中如果有抽象方法，该类必须定义为抽象！

2.2 抽象类的特点

1 ）抽象类和抽象方法必须使用abstract 关键字修饰

// 抽象类的定义
poublic abstract class 类名 {//抽象方法的定义public abstract void eat();
}

2 ）抽象类中不一定有抽象方法，有抽象方法的类一定是抽象类

3 ）抽象类不能实例化

1. 抽象类如何实例化呢？参考多态的方式，通过子类对象实例化，这叫做抽象类多态

4 ）抽象类的子类

1. 要么重写抽象类中的所有方法
2. 要么是抽象类

2.3 抽象类的成员特点

1 ）成员的特点

1. 成员变量

   • 既可以是变量
   • 也可以是常量

2. 构造方法

   • 空参构造
   • 有参构造

3. 成员方法

   • 抽象方法
   • 普通方法

2 ）代码实例

1. 动物类

public abstract class Animal {private int age = 20;private final String city = "北京";public Aniaml() {}public Animal(int age) {this.age = age;}public void show() {age = 40;System.out.printlncity = "上海";  // 这句话会报错，因为 city 是常量System.out.println(city);}public abstract void eat();
}

2. 猫类

public class Cat extends Animal {@Overridepublic void eat() {System.out.println("猫吃鱼");   }
}

3. 测试类

public class AnimalDemo  {public static void main(String[] args) {Animal a = new Cat();a.eat();a.show();}
}

2.4 抽象类的案例

1 ）案例需求

1. 请采用抽象类的思想实现猫和狗的案例，并在测试类中进行测试

2 ）代码实现

1. 动物类

public abstract class Animal {private String name;private int age;public Animal() {}public Animal(String name , int age) {this.name = name;this.age = age;}public String getName() {return name;}public void setName(String name) {this.name = name;}public int getAge {return age;}public void setAge (int age) {this.age = age;}public abstract void eat();
}

2. 猫类

public class Cat extends Animal {public Cat() {}public Cat(String name,int age) {super(name,age);}@Overridepublic void eat() {System.out.println("猫吃鱼");}
}

3. 狗类

public class Dog extends Animal {public Dog() {}public Dog (String name , int age) {super(name,age);}
}

4. 测试类

public class AnimalDemo {publci static void main(String[] args) {// 创建对象，按照多态的方式Animal a = new Cat();a.setName("加菲");a.setAge(5);System.out.Name + "," + a.getAge());a.eat();System.out.println("----------------");a = new Cat("加菲",5);System.out.Name() + "," + a.getAge());a.eat();}
}

3. 接口

3.1 接口的概述

1. 接口就是一种公共的规范标准，只要符合规范标准，大家都可以通用
2. java中的接口更多的体现在对行为的抽象

3.2 接口的特点

1 ）接口用关键字interface修饰

public interface 接口名 {}

2 ）类实现接口用implements 表示

public class 类名 implements 接口名 {}

3 ）接口 不能实例化

1. 接口如何实例化呢？参照多态的方式，通过实现类对象实例化，这叫接口多态
2. 多态的形态，具体类多态，抽象类多态，接口多态

4 ）接口的子类

1. 要么重写接口中的所有抽象方法
2. 要么子类也是抽象类

3.3 接口的成员特点

1 ）成员特点

1. 成员变量：只能是常量，默认修饰符 ：public static fianl

2. 构造方法：没有，因为接口主要是拓展功能，而没有具体存在

3. 成员方法：

   • 只能是抽象方法
   • 默认修饰符： public abstract
   • 关于接口中的方法，JDK8,JDK9中有一些新的特性

2 ）代码演示

1. 接口：

public interface Inter {public int num = 10;public final int num2 =20;int num3;// 下面这行代码是会报错的，因为接口没有构造方法public Inter() {}public abstract void method();}

2. 实现类

public class InterImpl extends Object implements Inter {public InterImpl() {super();}@Overridepublic void method() {System.out.println("method");}@Overridepublic void show() {System.out.println("show");}
}

3. 测试类

public class InterfaceDemo {public static void main(String[] args) {Inter i = new InterImpl();i.num = 20;System.out.println(i.num);i.num2 = 40;   // 这行代码会报错System.out.println(i.num2);System.out.println(Inter.num);}
}

3.4 接口的案例

1 ）案例需求

1. 对猫和狗进行训练，他们就可以跳高了，这里加入跳高功能
2. 侵犯采用抽象类和接口来实现猫和狗案例，并在测试类中进行测试

2 ）代码实现

1. 动物类

public abstract class Animal {private String name;private int sge;public Animal () {}public Animal(String name , int age) {this.name = name;this.age = age;}public String getName() {return name;}public void setName(String name) {this.name = name;}public int getName() {return age;}public void setName(int age) {this.age = age;}public abstract void eat();
}

2. 跳高接口

public interface Jumpping {public abstract void jump();
}

3. 猫类

public class Cat extends Animal implements JUmpping {public Cat() {}public Cat (String name , int age) {super(name,age);}@Overridepublic void jump() {System.out.println("猫可以跳高了")}
} 

4. 测试类

public class AnimalDemo {public static void main(String[] args) {//创建对象，调用方法Jumpping j = new Cat();j.jump();System.out.println("----------");Animal a = new Cat();a.setName("加菲");a.setAge(5);System.out.Name + "," + a.getAge());a.eat();a.jump(); // 代码会报错a = new Cat("加菲",5);System.out.Name() + "," + a.getAge());a.eat();System.out.println("---------");Cat c = new Cat();c.setName("加菲");c.setAge(5);System.out.Name() + "," + c.getAge());c.eat();c.junp();}
}

3.5 类和接口的关系

1 ）类与类的关系

继承关系，只能单继承，但是可以多层继承

2 ）类与接口的关系

实现关系，可以单实现，也可以多实现，还可以在继承一个类的同时实现多个接口

3 ）接口与接口的关系

继承关系，可以单继承，也可以多继承

3.6 抽象类和接口的区别

1 ）成员区别

1. 抽象类

   • 变量，常量，构造方法，有抽象方法，也有非抽象方法

2. 接口

   • 变量；抽象方法

2 ）关系区别

1. 类与类

   • 继承，单继承

2. 类与接口

   • 实现，可以单实现，也可以多实现

3. 接口与接口

   • 继承，单继承，多继承

3 ）设计理念区别

1. 抽象类

   • 对类抽象，包括属性，行为

2. 接口

   • 对行为抽象，主要是行为

4. 综合案例

4.1 案例需求

我们现在有乒乓球运动员和篮球运动员，乒乓球教练和篮球教练

为了出国交流，跟乒乓球相关的人员都需要学习英语

请用所学知识分析，这个案例中有那些具体类，那些抽象类，那些接口，并用代码实现

4.2 代码实现

1. 抽象人类

public abstract class Person {private String name;private int age;public Person() {} public Person(String name , int age) {this.name = name;this.age = age;}public String getName() {return name;}public void setName (String name) {this.name = name;}public int getAge() {return age;}public void setAge(int age) {this.age = age;}public abstract void eat();
}

2. 抽象运动员

public abstract class Player extends Person {public Player() {}public Player(String name, int age) {super(name,age);}public abstract void study();
}

3. 抽象教练类

public abstract class Coach extends Person {public Coach() {}public Coach(String name,int age) {super(name,age);}public abstract void teach();
}

4. 学习英语接口

public interface SpeakEnglish {public abstract void apeack();
}

5. 篮球教练

public class BasketballCoach extends Coach {public BasketballCoach() {}public BasketballCoach(String name,int age) {super(name,age);}@Overridepublic void teach() {System.out.println("篮球教练教如何运球和投球");}@Overridepublic void eat() {System.out.println("篮球教练吃羊肉，喝羊奶");}
}

6. 乒乓球教练

public class PingpangCoach extends implements SpeakEnglish {public PingpangCoach () {}public PingPangCoach(String name,int age) {super(name,age);}@Overridepublic void teach() {System.out.println("乒乓球教练教如何发球和接球");}@Overridepublic void eat() {System.out.println("乒乓球教练吃小白菜，喝大米粥");}@Overridepublic void speak() {System.out.println("乒乓球教练说英语");}
}

7. 乒乓球运动员

public class PingpangPlayer extends Player implements SpeackEnglish {public PingpangPlayer() {}public PingpangPlayer(String name, int age) {super(name,age);}@Overridepublic void study() {System.out.println("乒乓球运动员学习如何发球和接球")}@Overridepublic void eat() {System.out.println("乒乓球运动员吃大白菜，喝小米粥");}@Overridepublic void speak() {System.out.println("乒乓球运动员说英语");}
}

8. 篮球运动员

public class BasketballPlayer extends Player {public BasketballPlayer() {}public BasketballPlayer(String name,int age) {super(name,age);}@Overridepublic void study() {System.out.println("篮球运动员学习如何运球和投球")}@Overridepublic void eat() {System.out.println("篮球远动员吃牛肉h");}}

🎈看完了不妨给我点个赞吧，👉你的支持，是我每天更新的动力…