Java零基础学习（多态 抽象类 接口）

Java零基础学习（多态 抽象类 接口）

• 多态的概述

  1.多态概述
  	某一个事物，在不同时刻表现出来的不同状态。
  	举例：		Cat c=new Cat();
  			Animal a=new Cat();
  		猫可以是猫的类型。猫 m = new 猫();
  		同时猫也是动物的一种，也可以把猫称为动物。动物 d = new 猫();		
  2.多态前提
  	a:要有继承关系。
  	b:要有方法重写。 其实没有也是可以的，但是如果没有这个就没有意义。
  	c:要有父类引用指向子类对象。
  		父 f =  new 子();
  3.演示
  public class Animal {
      String name;
      int age;
      public void run(String name){
          System.out.println(name+"可以跑步");
      }
      public void eat(){
          System.out.println("吃饭");
      }
  }
  public class Cat extends Animal {
      public void eat(){
          System.out.println("猫吃鱼");
      }
      public static void catchMouse(){
          System.out.println("猫抓老鼠");
      }
  }
  class MyTest {
      public static void main(String[] args){
          Animal cat=new Cat();
      }
  }
  可以用父类的引用指向子类对象，前提是继承关系
  

  • 多态成员的访问特点

  1.多态中的成员访问特点
  	a:成员变量
  		编译看左边（先看父类有没有这个成员变量），运行看左边（如果有运行的话还是用父类的变量）。
  	b:构造方法
  		创建子类对象的时候，会访问父类的构造方法，对父类的数据进行初始化。
  	c:成员方法
  		编译看左边（先看父类有没有这个成员方法），运行看右边（如果有运行的话是用子类的方法）。
  	d:静态方法
  		编译看左边，运行看左边。
  		(静态和类相关，算不上重写，所以，访问还是左边的)
  2.演示
  public class Animal {
      String name="mimi";
      int age;
      public void run(){
          System.out.println("可以跑步");
      }
      public void eat(){
          System.out.println("吃饭");
      }
  }
  public class Cat extends Animal {
      String name="咪咪";
      public void eat(){
          System.out.println("猫吃鱼");
      }
      public static void catchMouse(){
          System.out.println("猫抓老鼠");
      }
  }
  class MyTest {
      public static void main(String[] args){
          Animal cat=new Cat();
          System.out.println(cat.name);
          cat.eat();
      }
  }
  运行结果：mimi
  		猫吃鱼
  

  • 多态的好处

  提高了代码的维护性
  提高了代码的扩展性
  

  • 多态的弊端

  1.不能使用子类的特有功能
  2.解决方法
  	把父类的引用强制转换为子类的引用
  3.演示
  class MyTest {
      public static void main(String[] args){
          Animal animal=new Cat();
          System.out.println(animal.name);
          animal.eat();
          Cat cat = (Cat) animal;
  
      }
  }
  

  • 多态的内存图解

  

  

  • 多态的题目分析

    1.看下面程序是否有问题，如果没有，说出结果
    	class Fu {
    		public void show() {
    			System.out.println("fu show");
    		}
    	}
    
    	class Zi extends Fu {
    		public void show() {
    			System.out.println("zi show");
    		}
    
    		public void method() {
    			System.out.println("zi method");
    		}
    	}
    
    	class DuoTaiTest3 {
    		public static void main(String[] args){
    			Fu f = new Zi();
    
    			f.method(); //编译不通过
    			f.show();
    		}
    	}
    	因为父类中没有method()方法,所以编译不通过
    	
    2.看下面程序是否有问题，如果没有，说出结果
    	class A {
    		public void show() {
    			show2();
    		}
    		public void show2() {
    			System.out.println("我");
    		}
    	}
    	class B extends A {
    		public void show2() {
    			System.out.println("爱");
    		}
    	}
    	class C extends B {
    		public void show() {
    			super.show();
    		}
    		public void show2() {
    			System.out.println("你");
    		}
    	}
    	public class DuoTaiTest4 {
    		public static void main(String[] args) {
    			A a = new B();
    			a.show(); //爱
    			
    			B b = new C();
    			b.show(); // 你
    		}
    	}
    	a对象调用show方法时先调用A类的show方法，然后show方法右调用了show2方法，因为B类重写了show2方法，所以调用B类的
    	b对象调用show方法因为C类重写了show方法，所以调用C类的show方法，C类又调用了父类的show方法，一直找到了A类，又调用show2方法，因为C重写了show2方法，所以调用C类的
    	最终的输出结果是：
    		        爱
    		        你
    

• 抽象类的概述和特点

  1.抽象类概述
  	动物不是一个具体的食物，而是一个抽象的事物，只有真正的猫，够才是具体的动物，所以，我们不应该在动物类中给出事物的具体表现，而是给出一个声明即可
  	在Java中，一个没有方法体的方法应该定义为抽象方法，而类中如果有抽象方法，该类就必须定义为抽象类
  2.抽象类的特点
  	a.抽象类和抽象方法必须用abstract关键字修饰
  		抽象类格式：		abstract class 类名{}
  		抽象方法格式：		public abstract void eat();
  	b.抽象类中不一定有抽象方法，有抽象方法的类一定是抽象类
  	c.抽象类可以有构造方法，抽象类不能进行实例化，所以抽象类的构造方法作用是用于子类访问父类数据时的初始化
  	d.抽象类不能直接实例化，但是可以按照多态的方法，由具体的子类实例化。这也是多态的一种，抽象类多态
  	e.抽象类的子类
  		要么是抽象类
  		要么重写抽象类中的抽象方法
  3.演示
  //抽象类	类中也可以有非抽象方法，也可以没有抽象方法
  public abstract class Animal {
      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 abstract class Dog extends Animal{
      
  }
  

  • 抽象类成员的特点

  1.抽象类成员的特点
  	a.成员方法：既可以是变量，也可以是常量
  	b.构造方法：可以有构造方法，用于子类访问父类数据的初始化
  	c.成员方法：既可以是抽象的，也可以是非抽象的。
  2.抽象类的成员方法特性
  	a.抽象方法：强制子类做的事情，非抽象的子类必须重写
  	b.非抽象方法：子类继承的事情，提高了代码的复用性
  

  • 案例演示

  public abstract class Animal {
      int age;
      String name;
      public abstract void eat();
      public void run(){
          System.out.println("动物可以跑步");
      }
  }
  public class Cat extends Animal{
      @Override
      public void eat() {
          System.out.println("猫吃鱼");
      }
  }
  public class Dog extends Animal{
      @Override
      public void eat() {
          System.out.println("狗吃骨头");
      }
  }
  public class Test {
      public static void main(String[] args) {
          //用多态的方法，由具体的子类实例化
          Animal animal = new Cat();
          Cat cat = new Cat();
          Dog dog = new Dog();
          animal.eat();
          animal.run();
          cat.eat();
          cat.run();
          dog.eat();
          dog.run();
      }
  }
  运行结果
  	猫吃鱼
  	动物可以跑步
  	猫吃鱼
  	动物可以跑步
  	狗吃骨头
  	动物可以跑步
  因为父类引用指向了猫类对象，所以animal对象调用的是Cat的方法
  

  • 抽象类中的面试题

  1.面试题1
  	一个类中如果没有抽象方法，可不可以定义为抽象类？如果可以，有什么意义？
  	答：可以，不能创建对象
  2.面试题2
  	abstract不能和哪些关键字使用
  	private    因为这个关键字修饰成员是不能被继承的，所以冲突
  	final      这个关键修饰的方法无法被重写，而abstract强制子类重写
  	static     static修饰的方法是属于类的
  
  

• 接口的概述及特点

  1.接口概述
  	有的狗可以跳火圈调高等，但这些都不是狗与生俱来的，所以把这些定义到动物类不合适，也不适合直接定义到猫或狗中，因为只有部分的猫或者狗有这功能。
  	所以，为了体现事物功能的扩展性，java中就提供了接口来定义这些额外功能，并不给出具体实现，哪些猫或狗需要被培训，只需要这部分猫狗把这些额外功能实现即可。
  2.接口特点
  	a.接口用关键字interface表示
  		格式：interface 接口名{}
  	b.类实现接口用implements表示
  		格式：class 类名 implements 接口名{}
  	c.接口不能实例化
  		接口可以通过多态的方式实例化
  	d.接口的子类
  		可以是抽象类，但是意义不大
  		可以是具体类，要重写接口中所有的抽象方法
  3.演示
  public interface Lead {
      public static final int h=10;
      public abstract void lead();
  }
  public interface JieWa {
      public abstract void jiewa();
  }
  public class Dog extends Animal implements Lead ,JieWa{
      @Override
      public void lead() {
          System.out.println("狗可以跳"+h+"米");
      }
      @Override
      public void eat() {
          System.out.println("狗吃骨头");
      }
      @Override
      public void jiewa() {
          System.out.println("狗可以接娃");
      }
  public class Test {
      public static void main(String[] args) {
          JieWa jieWa= new Dog();//可以通过多态的方式进行实例化
          Lead lead= new Dog();//可以通过多态的方式进行实例化
          lead.lead();
          jieWa.jiewa();
      }
  }
  
  

  • 接口成员的特点

  1.接口成员的特点
  	成员变量：只能是常量，并且是静态的。
  		默认修饰符：public static final
  		建议：自己手动给出
  	构造方法：接口没有构造方法
  	成员方法：只能是抽象方法
  		默认修饰符：public abstract
  		建议：自己手动给出
  2.演示
  //接口中没有构造方法
  public interface Lead {
      public static final int h=10;
      public abstract void lead();
  }
  
  

  • 类与类，类与接口，接口与接口的关系

  1.类与类
  	继承关系，只能实现单继承，可以多层继承
  2.类与接口
  	实现关系，可以单实现，也可以多实现
  	并且还可以在继承一个类的同时实现多个接口
  3.接口与接口
  	继承关系，可以单继承，也可以多继承
  4.演示
  public abstract class Animal {
      int age;
      String name;
      public abstract void eat();
      public void run(){
          System.out.println("可以跑步");
      }
  }
  public interface Lead {
      public static final int h=10;
      public abstract void lead();
  }
  public interface JieWa {
      public abstract void jiewa();
  }
  public class Dog extends Animal implements Lead ,JieWa{
      @Override
      public void lead() {
          System.out.println("狗可以跳"+h+"米");
      }
      @Override
      public void eat() {
          System.out.println("狗吃骨头");
      }
      @Override
      public void jiewa() {
          System.out.println("狗可以接娃");
      }
  public class Test {
      public static void main(String[] args) {
          JieWa jieWa= new Dog();//可以通过多态的方式进行实例化
          Lead lead= new Dog();//可以通过多态的方式进行实例化
          lead.lead();
          jieWa.jiewa();
      }
  }
  接口用多态的方式实现也不能调用子类中特有的方法
  
  

  • 抽象类和接口的区别

  1.成员区别
  	抽象类：
  		成员变量：可以有变量，也可以有长量
  		构造方法：有构造方法
  		成员方法：可以抽象，也可以非抽象
  	接口：
  		成员变量：只能是常量
  		构造方法：没有构造方法
  		成员方法：只能是抽象
  2.关系区别
  	类与类
  		继承，单继承
  	类与接口
  		实现，单实现，多实现
  	接口与接口
  		继承，单继承，多继承
  3.设计理念区别
  	抽象类	被继承体现的是："is a"的关系。	抽象类中定义的是该继承体系的共有性功能
  	接口	被实现体现的是："like a"的关系。  接口中定义的是该继承体系得扩展功能。
  
  

  JDK1.8之后在接口中提供了用default修饰的方法，可以给出功能的具体实现，子类可以继承下去用
        JDK1.8之后在接口中也可以定义静态方法，直接使用接口名来调用
  
  

Java零基础学习（多态 抽象类 接口）

原文：https://www.cnblogs.com/N-jack/p/14746208.html