Java进阶 -- 多肽

多肽

• 概念：同一个对象，表现出来的不同形态。
  代码中：父类 fu=new 子类();

• 多态中成员的访问特点：

  访问成员变量：编译看左边，运行看左边。输出的是父类的成员变量值。

  访问成员方法：编译看左边，运行看右边。执行的是子类重写的方法，如果子类没有重写该方法，执行就是父类中的该方法。

• 使用多态的好处
  好处：在定义方法时，参数列表中使用父类类型的参数，当调用方法的时候可以传递任意子类对象，可以大大简化代码书写，提高程序的扩展性。

 	public void useAnimal(Animal a){//Animal a=new Cat();  Animal a=new Dog(); 
  		Animal 	a=new Pig();
            a.eat();
    }

弊端：不能使用多态方式调用子类特有方法。如果需要调用，那么只能强制类型转化成子类对象之后再调用

• 类型转换

  /**
       * 饲养员类，操作动物
       */
      public class AnimalOperator {
          public void useAnimal(Animal a) { 
          	//Animal a=new Cat(); 
          	Animal a=new Dog()
            a.eat();
             //需求：如果这个动物是猫，那么调用猫的特有方法playGame()
             //难点：如何判断a是Cat类型，只有当变量a是Cat类型才可以将a强转成Cat。
              if(a instanceof Cat){
                  Cat c= (Cat) a;
                  c.playGame();
              }
          }
      }

  注意：如果类型不一致，那么强制类型转换就会出现ClassCastException类型转换异常。

• 总结：
  多态的体现形式：父类 对象名=new 子类() 记住！！！
  好处：能够提高程序的扩展性和灵活性，具体体现着方法的参数定义上。
  弊端：如果需要使用子类特有的方法，那么就需要强制类型转换。
  强制类型转换注意：在转换执行要进行类型判断。

/*
	Animal类,父类
*/
public class Animal {
    public void eat() {
        System.out.println("吃东西");
    }
}

/*
	猫类，并继承Animal类
*/
public class Cat extends Animal {
    @Override
    public void eat() {
        System.out.println("猫吃鱼");
    }

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

/*
	狗类，并继承Animal类
*/
public class Dog extends Animal {
    @Override
    public void eat() {
        System.out.println("狗吃骨头");
    }
}

/*
	动物操作类，userAnimal()的参数采用多肽的形式
*/
public class AnimalOpertor {
    public void userAnimal(Animal a) {
        a.eat();

        if (a instanceof Cat) { // 强制类型转换
            ((Cat) a).playGame(); // 调用子类中的方法
        }
    }
}

/*
	测试类
*/
public class AnimalDemo {
    public static void main(String[] args) {
        // 创建动物操作类
        AnimalOpertor ao = new AnimalOpertor();

        // 使用多肽的方式调用userAnimal()方法
        ao.userAnimal(new Cat());
        ao.userAnimal(new Dog());
        ao.userAnimal(new Pig());
    }
}

抽象类

• 概念：如果一个类的子类都必须要重写某个方法，并且该父类中的这个方法不需要具体的实现，那么父类的这个方法就可以定义成抽象方法，父类就必须是抽象类

• 定义格式：使用abstract关键字

public abstract class Animal {
            public int age=10;

            public abstract void eat();
        }

• 抽象类的特点：(可以不用记，因为违反了一条就编译报错)
  1、有抽象方法的类一定是抽象类，但是抽象类中不一定有抽象方法。
  2、抽象类必须使用多态创建对象： 抽象类 对象名=new 子类();
  3、抽象类的子类要么是抽象类要么重写所有的抽象方法。

• 成员的访问特点：
  1、抽象类中可以有成员变量、常量、静态成员变量
  2、抽象类可以有构造方法，创建子类对象的时候会执行父类构造方法，用于初始化父类成员变量。但是不能直接new抽象类。
  3、抽象类可以有抽象的成员方法也可以有非抽象的成员方法。

• 总结：
  为什么要使用抽象类？

  如果父类中的某些方法不需要具体实现(不需要方法体)，并且要求每个子类都要重写该方法，那么就可以将该方法定义成抽象方法，这个父类就需要定义成抽象类。格式如下：

public abstract class 类名{
                public abstract void eat();
            }

定义子类继承抽象类，以多态的形式创建对象：抽象类 对象名=new 子类();

/*
    抽象类
 */
public abstract class Animal {
    // 成员变量
    public int age;
    // 抽象方法
    public abstract void eat();

    // 非抽象方法
    public void run() {
        System.out.println("动物会跑");
    }

}

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

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

        a.eat();
        a.run();
        System.out.println(a.age);
    }
}

接口

• 概念：接口就是用来规定某些类具有的功能(方法)。
  语法：public interface 接口名{

     }
  

• 接口中成员的特点；

  1. 成员变量：接口中的成员变量都是常量，默认省略了public static final； 例如：int num=100;

  2. 构造方法：接口中没有构造方法

  3. 成员方法：在jdk1.7及以前版本接口中只有抽象方法，但是在1.7版本之后可以有default和static修饰的非抽象方法

• 类与接口的关系：

  1. 类与类：继承关系，类与类只能单继承，但是可以多层继承 public class 类名 extends 父类{} 常见
  2. 类与接口：实现关系，类可以实现多个接口 public class 类名 implements 接口1,接口2,…{} 常见
  3. 接口与接口：继承关系：一个接口可以继承多个接口 public interface 接口名 extends 接口1,接口2,…{} 很少

Java中是允许多继承，但是只能是接口和接口之间多继承。

public interface Jumpping {
    int age = 10;
    void jump();
}

public class Cat implements Jumpping {
    @Override
    public void jump() {
        System.out.println("猫会跳高了");
    }
}

public class JumppingDemo {
    public static void main(String[] args) {
        Jumpping j = new Cat();
        j.jump();
    }
}