学习java的第11天

01. 多态访问静态方法

• 代码实现

  /**
   * 多态
   * @author 海锋
   *
   */
  public class Demo01_Polymorphic {
  	public static void main(String[] args) {
  		//父类引用指向子类对象
  				Father01 clazz01 = new Son01();
  				//成员方法
  				//编译看左边，运行看右边。（方法重写）
  				clazz01.show1();
  				
  				System.out.println("----------------");
  				//静态方法
  				//编译看左边，运行看左边。（静态方法不是一个重写的方法，所以不支持动态绑定）
  				clazz01.show2();
  				
  				
  			}
  	}
  
  class Father01 {
  	public void show1() {
  		System.out.println("father show");
  	}
  	
  	public void show2() {
  		System.out.println("father static show");
  	}
  
  	
  }
  class Son01 extends Father01 {
  	@Override
  	public void show1() {
  		System.out.println("son show");
  	}
  	
  	@Override
  	public void show2() {
  		System.out.println("son static show");
  	}
  
  
  }
  

• 总结

  • 编译看左边，运行看右边
  • 静态方法是无法进行重写的

02. 多态的好处和弊端

• 代码实现

  /**
   * 多态的应用
   * @author 海锋
   *
   */
  public class Demo02_Polymorphic {
  	public static void main(String[] args) {
  		new FruitJuiceFactory().juice(new Apple("苹果"));
  	}
  }
  
  class FruitJuiceFactory {
  	public void juice(Fruit fruit) {
  		System.out.println("正在榨"  + fruit.getName() + "汁儿~~~");
  	}
  }
  class Fruit {
  	private String name;
  
  	public Fruit() {
  		super();
  		
  	}
  
  	public Fruit(String name) {
  		super();
  		this.name = name;
  	}
  
  	public String getName() {
  		return name;
  	}
  
  	public void setName(String name) {
  		this.name = name;
  	}
  }
  
  class Apple extends Fruit{
  
  	public Apple() {
  		super();
  	}
  
  	public Apple(String name) {
  		super(name);
  	}
  	
  }
  		
  class Banana extends Fruit {
  	public Banana() {
  		super();
  	}
  
  	public Banana(String name) {
  		super(name);
  		}
  	}
  	
  class Orange extends Fruit {
  		
  	public Orange() {
  		super();
  	}
  	public Orange(String name) {
  		super(name);
  	}
  }
  
  

• 多态好处

  • 提高了代码的复用性
  • 提高了代码的扩展性

• 多态坏处

  • 无法访问子类的特有成员

03. 多态中的类型转换

• 向上转型
  • 自动类型提升
  • 将一个对象的类型有子类型转换为父类型
• 向下转型
  • 强制类型转换
  • 将一个对象类型由父类型转换为子类型
• 注意事项
  • 多态中类型转换，需要具有子父类关系

04. 多态访问成员的特点

• 多态访问成员变量
  • 编译看左边，运行看左边
  • 如果编译不通过，那么程序报错；如果编译通过，那么就执行
• 多态访问成员方法
  • 编译看左边，运行看右边
  • 如果编译不通过，那么程序报错；如果编译通过，那么就执行
• 多态访问静态成员方法
  • 编译看左边，运行看左边
  • 如果编译不通过，那么程序报错；如果编译通过，那么就执行

05. 抽象类的概述

• 抽象类概述

  • 定义一个类，如果某一个行为是看不懂的，那么该类就该被定义为一个抽象类

• 语法

  • 使用abstract关键字

    public abstract class 类名 {
        
        数据类型 变量名;
        
        public abstract 返回值类型 方法名(参数类型 参数名1, 参数类型 参数名2...);
        
    }
    

• 抽象类特点

  • 抽象类不一定有抽象方法

  • 有抽象方法的类一定是抽象类

  • 抽象类不能直接创建对象

    • 使用多态的方式来穿件抽象类对象

  • 抽象类的子类

    • 抽象子类
      • 可以重写父类的抽象方法，也可以不重写父类的抽象方法
    • 具体子类
      • 必须重写父类的所有抽象方法

  • 代码实现

    abstract class  Animal{
    	
    	public abstract void eat();
    	
    	public abstract void walk();
    	
    }
    
    
    /**
     * eat依然是抽象的
     * @author qiuzhiwei
     *
     */
    abstract class Person extends Animal{
    	
    	@Override
    	public void walk() {
    		System.out.println("两条腿走路");
    	}
    	
    }
    
    class Chinese extends Person{
    
    	@Override
    	public void eat() {
    		System.out.println("吃米饭");
    	}
    	
    }
    

06. 抽象类的成员特点

• 总结
  • 成员变量
    • 可以是变量，也可以是常量
    • 不能用abstract修饰
  • 成员方法
    • 可以是抽象的，也可以是非抽象的
  • 构造器
    • 可以有构造器

07. 抽象类练习之猫狗问题

public class Demo03_Abstract {
	
	public static void main(String[] args) {
		Cat1 cat1 = new Cat1("橘猫",1);
		cat1.catchMouse();
		cat1.eat();
	}

}

public abstract class Animal1 {
	
	private String name;
	private int age;
	public Animal1() {
		super();
	}
	public Animal1(String name, int age) {
		super();
		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();
	
	public abstract void walk();
	
	public abstract void talk();
	
	
	

}

public class Cat1 extends Animal1 {
	
	
	
	public Cat1() {
		super();
	}

	public Cat1(String name, int age) {
		super(name, age);
	}

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

	@Override
	public void walk() {
		System.out.println("跳跃");
	}

	@Override
	public void talk() {
		System.out.println("喵喵喵");
	}
	
	
	public void catchMouse() {
		System.out.println("抓老鼠");
	}

}

08. 抽象类练习之学校老师问题

public class Demo04_Abstract {
	
	 public static void main(String[] args) {
		
		 ChineseTeacher chineseTeacher = new ChineseTeacher("张芷若",18);
		 chineseTeacher.eat();
		 chineseTeacher.teach();
		 
	}

}


public abstract class Teacher {
	
	private String name;
	private int age;
	public Teacher() {
		super();
	}
	public Teacher(String name, int age) {
		super();
		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 void eat() {
		System.out.println("吃米饭");
	}
	
	public abstract void teach();
	

}

public class MathTeacher extends Teacher{
	
	

	public MathTeacher() {
		super();
	}

	public MathTeacher(String name, int age) {
		super(name, age);
	}

	@Override
	public void teach() {
		System.out.println("教数学");
	}

}

public class ChineseTeacher extends Teacher{
	
	

	public ChineseTeacher() {
		super();
	}

	public ChineseTeacher(String name, int age) {
		super(name, age);
	}
	
	
	
	@Override
	public void eat() {
		System.out.println("吃满汉全席、佛跳墙");
	}

	@Override
	public void teach() {
		System.out.println("教中文");
		
	}

}

09. abstract关键字注意事项

• 如果一个类中没有抽象方法，但是依然使用abstract关键字修饰该类，有什么用？
  • 让该类不能直接创建对象，而是通过多态的形式进行实例化
• abstract不能喝哪些关键字共存？
  • static
    • 第一角度：使用static修饰的方法，可以直接使用类名.调用，而直接使用类名.调用的话，该抽象方法依然没有具体化
    • 第二角度：使用static修饰的方法，不能进行方法重写，方法无法具体化
  • final
    • 使用final修饰的方法，不能进行方法重写
  • private
    • 使用private修饰的方法，不能别继承，导致不能进行方法重写

10. 接口

• 接口概述

  • 从狭义的角度就是interface
  • 从广义的角度讲对外提供规则的都是接口

• 语法

  interface 接口名{
      
      public abstract 返回值类型 方法名(参数类型 参数名1,参数类型 参数名2...);
      
  }
  

• 接口特点

  • 类与接口之间是实现关系
  • 接口也不能直接实例化
    • 通过多态的方式来实例化
  • 接口的子类
    • 抽象子类
    • 普通子类

• 接口的成员特点

  • 成员变量
    • 只能是常量，不能是变量
    • 而且java会默认补全public static final 修饰符
  • 构造器
    • 没有构造器
    • 接口中没有变量需求进行初始化
  • 成员方法
    • 只能是抽象方法
    • 而且java会默认补全public abstract 修饰符

11. 类与类、类与接口、接口与接口

• 类与类
  • 继承关系
  • 只能单继承，可以多层继承
• 类与接口
  • 实现关系
  • 可以单实现，也可以多实现
• 接口与接口
  • 继承关系
  • 可以单继承，也可以多继承，也可以多层继承