java基础知识（多态 抽象类 接口）

java第八天之学到辽~

1.1 多态

* 多态概述

一个事物，在不同时刻表现出来的不同状态。

* 多态前提

(1) 要有继承关系
(2) 要有方法重写
(3) 要有父类引用指向子类对象

* 多态中的成员访问特点

(1) 成员变量
编译看左边，运行看左边
(2) 构造方法
创建子类对象的时候，会访问父类的构造方法，对父类的数据进行初始化。
(3) 成员方法
编译看左边，运行看右边。
(4) 静态方法
编译看左边，运行看左边

* 多态的好处

(1) 提高了代码的维护性(继承保证)
(2) 提高了代码的扩展性(由多态保证)

* 多态的弊端

(1) 不能使用子类特有的功能
(2) 把父类的引用强制转换为子类的引用

* 多态的例子

public class animal {
   String name;
   int age;
   public void eat(){
       System.out.println("吃饭");
   }
   public void sleep(){
       System.out.println("睡觉");
   }
}


public class Cat extends animal {

   @Override
   public void eat() {
       System.out.println("猫吃老鼠");

   }
   public void play(){
       System.out.println("玩球球");
   }
}


public class Dog extends animal {
   @Override
   public void eat() {
       System.out.println("狗吃肉");
   }
   public void lookdoor(){
       System.out.println("看门");
   }
}



public class Mytest {
   public static void main(String[] args) {
       animal aa = new Cat(); //向上转型
       aa.age=3;
       aa.name="大脸";
       System.out.println(aa.name);
       System.out.println(aa.age+"岁");
       aa.eat();
       aa.sleep();
       Cat aa1=(Cat)aa; //向下转型
       aa1.play();
       System.out.println("..................................");
       animal bb=new Dog();//向上转型
       bb.age=2;
       bb.name="大头";
       System.out.println(bb.name);
       System.out.println(bb.age+"岁");
       bb.sleep();
       bb.eat();
       ((Dog) bb).lookdoor();//向下转型

   }
}

1.2 抽象类

* 抽象类概念

一个没有方法体的方法应该定义为抽象方法，而类中如果有抽象方法，该类必须定义为抽象类。

* 抽象类的特点

(1) 抽象类和抽象方法必须用abstract关键字修饰
(2) 抽象类格式:  abstract class 类名 {}
(3) 抽象方法格式: public abstract void eat();
(4) 抽象类不一定有抽象方法，有抽象方法的类一定是抽象类
(5) 抽象类中可以有构造方法,但抽象类不能进行实例化
(6) 抽象类的子类
    是抽象类
    重写抽象类中的所有抽象方法

* 抽象类的成员特点

成员变量：既可以是变量，也可以是常量
构造方法：有
作用：用于子类访问父类数据的初始化
成员方法：既可以是抽象的，也可以是非抽象的

* 抽象类练习例子

abstract public class teacher {
   String name;
   int age;
   public abstract void work();
}


public class Basicteacher extends teacher {
   @Override
   public void work() {
       System.out.println("教基础语法");
   }
}


public class Employmentteacher extends teacher{
   int bonus;
   @Override
   public void work() {
       System.out.println("教就业实例");
   }
}

public class test {
   public static void main(String[] args) {
       teacher th = new Basicteacher();
       th.age=35;
       th.name="李某某";
       System.out.println("年龄是"+th.age);
       System.out.println(th.name);
       th.work();
       System.out.println("......................");
       teacher th2 = new Employmentteacher();
       th2.age=40;
       th2.name="张某某";
       ((Employmentteacher) th2).bonus=500;
       System.out.println("年龄是"+th2.age);
       System.out.println(th2.name);
       System.out.println("额外奖金"+((Employmentteacher) th2).bonus);
       th2.work();

   }
}

1.3 接口

* 接口的概念

 为了体现事物功能的扩展性，Java中就提供了接口来定义这些额外功能

* 接口特点

(1) 接口用关键字interface表示   格式:  interface 接口名 {}
(2) 类实现接口用implements表示  格式: class 类名 implements 接口名 {}

* 接口怎样进行实例化

按照多态的方式来实例化

* 接口的成员特点

成员变量：只能是常量，并且是静态的 （ 默认修饰符：public static final）
构造方法：接口没有构造方法
成员方法：只能是抽象方法（默认修饰符：public abstract）

* 类与类,类与接口,接口与接口的关系

(1) 类与类：
    继承关系,只能单继承,可以多层继承
(2) 类与接口：
    实现关系,可以单实现,也可以多实现
    并且还可以在继承一个类的同时实现多个接口
(3) 接口与接口：
    继承关系,可以单继承,也可以多继承

* 接口的例子

 动物类：姓名，吃饭，
 动物培训接口：跳高
 猫继承动物类
 狗继承动物类
 部分猫继承猫类并实现跳高接口
 部分狗继承狗类并实现跳高接口

public class test {
  public static void main(String[] args) {
    
      animal an = new cat();
      an.name="哈哈";
      an.age=3;

      System.out.println(an.name+" "+an.age+" ");
      an.eat();

      animal an1 = new dog();
      an1.name="呵呵";
      an1.age=1;

      System.out.println(an1.name+" "+an1.age);
      an1.eat();
      jumpinterface aa = new cat1();
      ((cat1) aa).name="小哈";
      System.out.println(((cat1) aa).name);
      System.out.println(((cat1) aa).age);
      cat1 a=(cat1)aa;
      a.eat();
      aa.jump();
      jumpinterface bb = new dog1();
      ((dog1) bb).name="小呵";
      System.out.println(((dog1) bb).name);
      System.out.println(((dog1) bb).age);
      ((dog1) bb).eat();
      bb.jump();

  }
}
abstract class animal{
  String name;
  int age=3;

  public abstract void eat();

}
class cat extends animal{
  @Override
  public void eat() {
      System.out.println("猫吃鱼");
  }
}
class dog extends animal{
  @Override
  public void eat() {
      System.out.println("狗吃骨头");
  }
}
class cat1 extends cat implements jumpinterface{
  @Override
  public void jump() {
      System.out.println("经过猫的不断努力，学会了跳高");
  }
}
class dog1 extends dog implements jumpinterface{
  @Override
  public void jump() {
      System.out.println("经过狗的不断努力，学会了跳高");
  }
}

interface jumpinterface{
  public abstract void jump();
}