多态

Java中的多态

1.引用多态

父类的引用可以指向本类的对象
Animal obj1=new Animal();
父类的引用可以指向子类的对象
Animal obj2=new Dog();
Animal obj3=new Cat();

2.方法多态(方法的重写)

obj1.eat(); //调用父类的
obj2.eat()；//子类重写
obj3.eat()；//子类重写，依然调用父类的

多态的实现：继承+方法的重写+父类引用指向子类对象

  1. public class Animal {
  2.     String name;
  3.     int age;
  5.     public Animal(String name, int age) {
  6.         this.name = name;
  7.         this.age = age;
  8.     }
  10.     public String getName() {
  11.         return name;
  12.     }
  14.     public void eat(){
  15.         System.out.println("吃东西 ");
  16.     }
  17. }
  1. public class Dog extends Animal{
  2.     @Override      //
  3.     // ，理解为限定符，意思是告诉编译器，下面这个方法是重写的方法
  4.     public String getName() {
  5.         //return super.getName();//super代表弗雷对象
  6.         return "狗";
  7.     }
  9.     public Dog() {
  10.         super("狗", 1);
  11.     }
  13.     @Override
  14.     public void eat() {
  15.         System.out.println("吃棒骨");
  16.     }
  17. }
  1. public class Cat extends Animal {
  2.     public Cat(String name, int age) {
  3.         super(name, age);
  4.     }
  6.     @Override
  7.     public void eat() {
  8.         System.out.println("吃鱼");
  9.     }
  10. }
  1. public class Main {
  3.     public static void main(String[] args) {
  4.         //创建父类对象
  5.         Animal obj1 = new Animal("斑点狗",1);
  6.         //父类引用指向子类对象
  7.         Animal obj2 = new Dog();
  8.         Animal obj3 = new Cat("猫",1);
  10.         //调用方法
  11.         obj1.eat();
  12.         obj2.eat();
  13.         obj3.eat();
  14.     }
  15. }

Java中的多态中的引用类型转换

1.向上类型转换（隐式/自动类型转换），是小类型到大类型的转换
Dog obj1=new Dog();
Animal obj2=obj1；
2.向下类型转换（强制类型转换），是大类型到削类型的转换
Dog obj3=( Dog)obj2；

  1. public class Main {
  3.     public static void main(String[] args) {
  4. //        //创建父类对象
  5. //        Animal obj1 = new Animal("斑点狗",1);
  6. //        //父类引用指向子类对象
  7. //        Animal obj2 = new Dog();
  8. //        Animal obj3 = new Cat("猫",1);
  9. //
  10. //        //调用方法
  11. //        obj1.eat();
  12. //        obj2.eat();
  13. //        obj3.eat();
  14.         Dog dog = new Dog();
  15.         Animal animal = dog;//隐式自动类型转换，父类型可以向子类型转换
  17.         Dog dog2 = (Dog)animal;//强制类型转换
  18.     }
  19. }

使用instanceof 检测是否可以强制转换

  1. public class Main {
  3.     public static void main(String[] args) {
  4. //        //创建父类对象
  5. //        Animal obj1 = new Animal("斑点狗",1);
  6. //        //父类引用指向子类对象
  7. //        Animal obj2 = new Dog();
  8. //        Animal obj3 = new Cat("猫",1);
  9. //
  10. //        //调用方法
  11. //        obj1.eat();
  12. //        obj2.eat();
  13. //        obj3.eat();
  14.         Dog dog=new Dog();
  15.         Animal animal= dog;
  16.         System.out.println(animal.toString());//每个对象都可以toString输出该对象的类型
  17.         //instanceof的原理大概是判断该对象的类型
  18.         if(animal instanceof Dog){ //左边的要转换成右边的类型
  19.             Dog dog2 =(Dog)animal;
  20.             System.out.println("类型可以转换");
  21.         }else{
  22.             System.out.println("无法类型转换");
  23.         }
  24.     }
  25. }

Java中的抽象类

实际上用的很少，因为java很多类库已经设计好了
1.语法定义
抽象类前使用abstract关键字修饰，则该类为抽象类。
2.作用
限定子类必须实现某些方法，但不关注实现细节
3.使用规则
A.abstract定义抽象类
B.abstract定义抽象方法，只有声明，不需要实现
C.包含抽象方法的类是抽象类
D.抽象类中可以包含普通的方法，也可以没有抽象方法
E.抽象类不能直接创建，可以定义引用变量

Java中的接口

类是一种具体实现体，而接口定义了某一批类所遵守的规范，接口不关心这些类的内部数据，也不关心这些类里方法的实现细节，它只规定这些类里必须提供某些方法。
image.png

使用接口：

一个类可以实现一个或多个接口，实现接口使用implements关键字。
Java中一个类只能继承一个父类，是不够灵活的，通过实现多个接口可以做为补充
如果要继承父类，继承父类必须在实现接口之前
创建接口类：

  1. //接口的存在就是弥补java的单继承
  2. //java单继承主要继承的是父类的数据
  3. //而一个类的行为方法一都是使用接口进行扩展
  4. //一个类可以实现多个接口，扩展无限多的方法
  6. public interface IAction {
  7.     void test1();//默认接口中的方法就是公有方法，不需要实现
  8.     void test2();//还可以继续写test3、test4...可以没有实现
  9. }

实现接口：

image.png

  1. public class Test implements IAction{
  3.     @Override
  4.     public void test1() {
  5.         System.out.println("啪啪啪");
  6.     }
  7.     @Override
  8.     public void test2() {
  9.         System.out.println("嘿嘿嘿");
  10.     }
  11. }

接口的特点：

接口默认就是abstract修饰
接口默认也只能是public的
接口可以继承自多个父接口
接口中的属性是常量（public static final…）
接口中的方法都是抽象方法（public abstract）

匿名内部类

在界面设计中用的非常多

  1. public interface IAction2 {
  2.     void study();
  3. }
  1. public interface IAction3 {
  2.     void playGame();
  3. }
  1. public class Student implements IAction2{ 
  3.     //学生一般都会学习
  4.     @Override
  5.     public void study() {
  6.         System.out.println("学习");
  7.     }
  8.     //某些学生喜欢做一些动作
  9.     public void addAction(IAction3 action3){  //传递一个参数
  10.         action3.playGame();
  11.     }
  12. }
  1. public class Main {
  3.     public static void main(String[] args) {
  4.         Student student = new Student(); //创建一个学生
  5.         student.study();
  7.         //某些学生想要玩游戏
  8.         //如果一个方法参数是接口类型，
  9.         // 那么需要传递一个对象，对象所在类必须实现了对应的接口
  11.         //内部类对象obj
  12.         MyObj obj = new MyObj();//在java中创建对象必须new出来，除了字符串赋值可以直接赋一个常量字符串
  13.         student.addAction(obj);//开后门，student类只能玩游戏的（接口2），但增加了一个可以实现接口3的函数，相当于同时有接口2、3
  15.         //匿名内部类对象
  16.         //1.创建了一个匿名类 
  17.         //2.匿名类实现了一个接口IAction3
  18.         //3.创建了一个匿名类对象
  19.         student.addAction(new IAction3() {
  20.             @Override
  21.             public void playGame() {
  22.                 System.out.println("玩游戏真爽2");
  23.             }
  24.         });
  25.     }
  27.     //创建一个静态内部类（匿名内部类）
  28.     public static class MyObj implements  IAction3{
  30.         @Override
  31.         public void playGame() {
  32.             System.out.println("玩游戏真爽");
  33.         }
  34.     }
  35. }

image.png