day09

09.01 面向对象（多态的概述及其代码实现）
 A.多态概述（ploymorphic）
　　事物存在的多种形态
 B.多态前提
　　a.要有继承
　　b.要有方法重写
　　c.要有父类引用子类对象
 C.案例演示

package day09;
public class day09_01 {
    public static void main(String[] args) {
        Cat c = new Cat();
        c.eat();
        
        Animal a = new Cat();        //父类引用指向子类对象
        a.eat();
    }
}
class Animal{
    public void eat(){
        System.out.println("Animal eat");
    }
}
class Cat extends Animal{
    public void eat(){
        System.out.println("Cat eat");
    }
}

09.02 面向对象（多态的成员访问特点）
 A.多态中的成员方法特点
　　a.成员变量
　　　　编译看左，运行看左
　　b.成员方法（指的是非静态的成员方法）
　　　　编译看左，运行看右
　　c.静态方法
　　　　编译看左，运行看左
　　　　(静态和类相关，算不上重写，所以，访问还是看右边)
 B.案例演示

package day09;

public class day09_02 {
    public static void main(String[] args) {
        Father f = new Son();
        System.out.println(f.num);
    }
}
//成员变量，（父类引用指向子类对象）左左
class Father {
    int num = 10;
}
class Son extends Father{
    int num = 20;
}

public class day09_02 {
    public static void main(String[] args) {
        Father f = new Son();
        f.print();
    }
}
//成员方法，（父类引用指向子类对象）左右
class Father {
    public void print(){
        System.out.println("father");
    }
}
class Son extends Father{
    public void print(){
        System.out.println("Son");
    }
}
---------------------------------
public class day09_02 {
    public static void main(String[] args) {
        Father f = new Son();
        f.method();
    }
}
//静态得到，（父类引用指向子类对象）左左
class Father {
    public static void method(){
        System.out.println("father static method");
    }
}
class Son extends Father{
    public static void method(){
        System.out.println("Son  static method");
    }
}

09.03 面向对象（多态的概述及其代码实现）
　　成员方法
　　　　编译看左，运行看右

09.04 面向对象（多态的概述及其代码实现）
　　静态方法
　　　　编译看左，运行看左
09.05 面向对象（超人的故事）
 A.案例演示

package day09;
public class day09_05 {
    /*基本数据类型自动类型提升和强制类型转换
     * int i = 10;
     * byte b = 20;
     * i=b;                //自动类型提升byte--> int
     * b=byte()i;        //强制类型提升int -->byte
     */
    public static void main(String[] args) {
        SuperMan p =new SuperMan();
        System.out.println(p.name);
        p.Tlak();
        //无法用 p.fly()调用子类的fly()方法，因为编译看左，父类没有fly()，编译失败
        SuperMan sm = (SuperMan)p;
        sm.fly();
    }
}
class Person{
    String name = "John";
    public void Tlak(){
        System.out.println("tlak bussiness");
    }
}
class SuperMan extends Person{
    String name = "SuperMan";
    public void Tlak(){
        System.out.println("tlak Son class");
    }
    public void fly(){
        System.out.println("fly out");
    }
}

09.06 面向对象（多态的向上转型和向下转型）
　　Person p = new Person()
　　SuperMan sm = (SuperMan)p;
09.07 面向对象（多态的好处和弊端）
 A.多态的好处
　　a.提高了代码的复用性
　　b.提高了代码的拓展性
 B.案例演示
　　多态的好处

package day09;
public class day09_07 {
    public static void main(String[] args) {
        method(new Cat7());
        method(new Dog7());
    }
    /*public static void method(Cat7 c){
        c.eat();
    }*/
    public static void method(Animal7 a){
    //    a.eat();      //调用子类共有的属性
        //如果先调用子类特有的属性呢？
        //关键字 ：instanceof,判断前面的引用是否是后边的数据类型
        if(a instanceof Cat7){
            Cat7 c = (Cat7)a;
            c.eat();
            c.catchMouse();
        }
    }
}
class Animal7{
    public void eat(){
        System.out.println("Animal eat fish");
    }
}
class Cat7 extends Animal7{
    public void eat(){
        System.out.println("Cat eat fish");
    }
    public void catchMouse(){
        System.out.println("catch Mouse");
    }
}
class Dog7 extends Animal7{
    public void eat(){
        System.out.println("Dog eat rou");
    }
    public void LookHome(){
        System.out.println("LookHome");
    }
}

 C.多态的弊端
　　不能使用子类的特有属性和行为
D.案例演示
　　method(Animal a)
　　method(Cat c)
09.08 面向对象（多态的题目分析）
09.09 面向对象（抽象类的概述机器特点）
 A.抽象类概述
　　当你无法描述一个类时，就将她定义为抽象的。抽象就是看不懂的。抽象就是看不懂的（********）
 B.抽象类特点
　　a.抽象类和抽象方法必须使用abstract关键字来修饰
　　　　abstract class 类名{}
　　　　public abstract void eat();
　　b.抽象类不一定由抽象方法，有抽象方法的类一定是抽象类或者接口
　　c.抽象类不能被实例化，那么抽象类如何实例化呢？
　　　　按照多态的方式，由句体的子类实例化。其实这也是多态的一种，抽象类多态
　　d.抽象类的子类
　　　　要么抽象类
　　　　要么是重写抽象类中所有抽象方法(一般选择这种方式)（**********）
 C.案例演示

package day09;
public class day09_09 {
    /*a.抽象类和抽象方法必须使用abstract关键字来修饰
          abstract class 类名{}
          public abstract void eat();
      b.抽象类不一定由抽象方法，有抽象方法的类一定是抽象类或者接口
      c.抽象类不能被实例化，那么抽象类如何实例化呢？
          按照多态的方式，由句体的子类实例化。其实这也是多态的一种，抽象类多态
      d.抽象类的子类
          要么抽象类
          要么是重写抽象类中所有抽象方法(一般我们这么使用)
     */
    public static void main(String[] args) {
    //    Animal9 a = new Animal9();           //抽象方法不能实例化
        //用父类引用指向子类对象来调用子类方法
        Animal9  a = new Cat9();
        a.eat();
    }
}
abstract class Animal9{             //抽象类
    public abstract void eat();     //抽象方法
}
class Cat9 extends Animal9{
    public void eat(){
        System.out.println("Cat eat fish");
    }
}

09.10 面向对象（抽象类的成员特点）
 A.抽象类的成员特点
　　a.成员变量：既可以是变量，也可以是常量。abstract不能修饰成员变量
　　b.构造方法：有。用于子类访问父类数据的初始化
　　c.成员方法：抽象，非抽象都可以
 B.案例特点

09.10 面向对象（抽象类的成员特点）
  A.抽象类的成员特点
　　a.成员变量：既可以是变量，也可以是常量。abstract不能修饰成员变量
　　b.构造方法：有。用于子类访问父类数据的初始化
　　c.成员方法：抽象，非抽象都可以
  B.案例特点

09.10 面向对象（抽象类的成员特点）
  A.抽象类的成员特点
      a.成员变量：既可以是变量，也可以是常量。abstract不能修饰成员变量
      b.构造方法：有。用于子类访问父类数据的初始化
      c.成员方法：抽象，非抽象都可以
  B.案例特点
09.11 面向对象（岳不群,东方不败）
09.12 面向对象（猫狗类）
09.13 面向对象（老师类）
09.14 面向对象（员工类）
    假如我们再开发一个系统程序是需要堆程序员进行设计，程序员包括3个属性：姓名/工号/工资
       经理，除了含有程序员的属性外，还有一个奖金属性
      请使用继承的思想设计出程序员类和经理类。要求类中提供必要的方法进行属性访问*/
09.15 面向对象（抽象类中的面试题）
     面试题：
     1.一个抽象类如果没有抽象方法，可不可以定义为抽象类？如果可以，有什么意义？
         可以。这么做的目的只有一个，就是不让其他类创建本类对象，交给子类完成
     2.abstract不能和哪些关键字共存、、
         abstract和static/final,private
         static。被static修饰的可以用类名.调用，但是类名.调用抽象方法是没有意义的
         final。   被abstract修饰的方法强制子类重写，被final修饰的不让子类重写
         private.被abstract修饰的是为了让子类看到并强制重写
09.16 面向对象（接口的概述及其特点）
  A.
  B.接口特点
      a:接口关键字：interface。 使用方式：   interface  接口名  {}
      b:类实现接口：implements 使用方法：  class 类名 implements 接口名 {}
      c:接口不能实例化。所以可以按照多态的方式进行实例化
      d:接口的子类：可以是抽象类（意义不大），可以是具体类，要重写接口中的所有抽象方法(********)
  C.案例演示
09.17 面向对象（接口的成员特点）
  A.接口成员特点
      成员变量：只能是常量，并且是静态的公共的
          默认修饰符是：public static final
          建议：自己手动给出
      构造方法：无
      成员方法：只能是抽象方法
          建议：自己手动给出
 09.18 接口与接口，类 的关系
  A.类与类，类与接口，接口与接口
      a.类与类：       继承关系。只能单继承
      b.类与接口：   实现关系，单实现和多实现
      c.接口与接口:继承关系，单继承和多继承
 09.19 面向对象（抽象类和接口的区别）
  A.成员区别
      抽象类：
          成员变量：可以变量也可以常量
          构造方法：有
          成员方法：可以抽象，可以非抽象
      接口：
          成员变量：只能常量
          成员方法：只能抽象
  C.设计理念：
      抽象类：体现的是：“is a”
      接口 ：   体现的是：“like a”
09.20 面向对象（猫狗类）
 A.案例演示<猫狗类>
     动物类: 姓名 年龄 吃饭 睡觉
     猫和狗
     动物培训接口:跳高

09.11 面向对象（岳不群,东方不败）

package day09;
public class day09_11 {
    public static void main(String[] args) {
        岳不群 小岳子 = new 岳不群();
        小岳子.自宫();
    }
}
abstract class 葵花宝典{                   //抽象类
    public abstract void 自宫();            //定义抽象方法
}
class 岳不群 extends 葵花宝典{
    public void 自宫(){                    //必须重写父类的抽象方法
        System.out.println("用牙签");
    }
}
class 林平之 extends 葵花宝典{
    public void 自宫(){                    //必须重写父类的抽象方法
        System.out.println("用指甲刀");
    }
}
class 东风不败 extends 葵花宝典{
    public void 自宫(){                    //必须重写父类的抽象方法
        System.out.println("用锤子");
    }
}

09.12 面向对象（猫狗类）

package day09;
public class day09_12 {
    public static void main(String[] args) {
        Cat12 c = new Cat12("加菲猫",80);
        System.out.println(c.getName() + "..." + c.getAge());
        c.eat();
        c.catchMouse();
        
        Dog12 d = new Dog12("八公",20);
        d.eat();
        d.LookHome();
    }
}
abstract class Animal12{
    private String name;
    private int age;
    //
    public Animal12(){}
    public Animal12(String name,int age){
        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();              //抽象方法必须放在抽象类种
} 
class Cat12 extends Animal12{
    public Cat12(){}
    public Cat12(String name,int age){
        super(name,age);
    }
    public void eat(){                      //必须重写父类的抽象方法
        System.out.println("Cat eat");
    }
    public void catchMouse(){
        System.out.println("catch mouse");
    }
}
class Dog12 extends Animal12{
    public Dog12(){}
    public Dog12(String name,int age){
        super(name,age);
    }
    public void eat(){                      //必须重写父类的抽象方法
        System.out.println("dog eat rou");
    }
    public void LookHome(){
        System.out.println("look home");
    }
}

09.13 面向对象（老师类）

package day09;
public class day09_13 {
    public static void main(String[] args) {
        BaseTeacher bt = new BaseTeacher("fengjia",18);
        bt.teach();
    }
}
abstract class Teacher{
    private String name;
    private int age;
    //
    public Teacher(){}
    public Teacher(String name,int age){
        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 teach();
}
class BaseTeacher extends Teacher{
    public BaseTeacher(){}
    public BaseTeacher(String name,int age){
        super(name,age);
    }
    public void teach(){
        System.out.println("我的姓名是："+ this.getName() + "，我的年龄是："+ this.getAge()+",讲的内容是Java基础");
        
    }
}

09.14 面向对象（员工类）
　　假如我们再开发一个系统程序是需要堆程序员进行设计，程序员包括3个属性：姓名/工号/工资
　　经理，除了含有程序员的属性外，还有一个奖金属性
　　请使用继承的思想设计出程序员类和经理类。要求类中提供必要的方法进行属性访问*/

package day09;
public class day09_14 {
    public static void main(String[] args) {
        Coder c = new Coder("demaxiya",8,8000,5000);
        c.work();
    }
}
/*假如我们再开发一个系统程序是需要堆程序员进行设计，程序员包括3个属性：姓名/工号/工资
 * 经理，除了含有程序员的属性外，还有一个奖金属性
 * 请使用继承的思想设计出程序员类和经理类。要求类中提供必要的方法进行属性访问*/

class Employee{
    private String name;
    private int id;
    private double salary;
    public Employee(){}
    public Employee(String name,int id,double salary){
        this.name = name;
        this.id = id;
        this.salary=salary;
    }
    //
    public String getName(){
        return name;
    }
    public void setName(String name){
        this.name =name;
    }
    public int getId(){
        return id;
    }
    public void setId(int id){
        this.id = id;
    }
    public double getSalary(){
        return salary;
    }
    public void setSalary(double salary){
        this.salary = salary;
    }
}
class Coder extends Employee{
    private int bonus;                //定义本类的成员变量
    public Coder(){}
    public Coder(String name,int id,double salary,int bonus){
        super(name,id,salary);
        this.bonus = bonus;            //this进行赋值
    }
    public void work(){
        System.out.println("我的姓名是："+ this.getName() + "，我的工号是："+this.getId()+",我的工资是："+this.getSalary()+"，我的奖金是："+this.bonus);
    }
}

09.15 面向对象（抽象类中的面试题）
　　面试题：
　　1.一个抽象类如果没有抽象方法，可不可以定义为抽象类？如果可以，有什么意义？
　　　　可以。这么做的目的只有一个，就是不让其他类创建本类对象，交给子类完成
　　2.abstract不能和哪些关键字共存、、
　　　　abstract和static/final,private
　　　　static。被static修饰的可以用类名.调用，但是类名.调用抽象方法是没有意义的
　　　　final。 被abstract修饰的方法强制子类重写，被final修饰的不让子类重写
　　　　private.被abstract修饰的是为了让子类看到并强制重写

package day09;

public class day09_15 {

    /**
     面试题：
     1.一个抽象类如果没有抽象方法，可不可以定义为抽象类？如果可以，有什么意义？
         可以。这么做的目的只有一个，就是不让其他类创建本类对象，交给子类完成
     2.abstract不能和哪些关键字共存、、
         abstract和static/final,private
         static。被static修饰的可以用类名.调用，但是类名.调用抽象方法是没有意义的
         final。   被abstract修饰的方法强制子类重写，被final修饰的不让子类重写
         private.被abstract修饰的是为了让子类看到并强制重写
     */
    public static void main(String[] args) {

    }
}
/*abstract class Demo{
    //public static abstract void print();//错误，这是不能共存的
    //public final abstract void print();//错误，这是不能共存的
    //private abstract void print();    /错误，这是不能共存的
}*/

09.16 面向对象（接口的概述及其特点）
  A.
  B.接口特点
　　a:接口关键字：interface。 使用方式： interface 接口名 {}
　　b:类实现接口：implements 使用方法： class 类名 implements 接口名 {}
　　c:接口不能实例化。所以可以按照多态的方式进行实例化
　　d:接口的子类：可以是抽象类（意义不大），可以是具体类，要重写接口中的所有抽象方法(********)
 C.案例演示

09.17 面向对象（接口的成员特点）
  A.接口成员特点
　　成员变量：只能是常量，并且是静态的公共的
　　　　默认修饰符是：public static final
　　　　建议：自己手动给出
　　构造方法：无
　　成员方法：只能是抽象方法
　　　　建议：自己手动给出
09.18 接口与接口，类 的关系
  A.类与类，类与接口，接口与接口
　　a.类与类： 继承关系。只能单继承
　　b.类与接口： 实现关系，单实现和多实现
　　c.接口与接口:继承关系，单继承和多继承

package day09;
public class day09_18 {
    public static void main(String[] args) {

    }
}
interface InterA{
    public abstract void printA();
}
interface InterB{
    public abstract void printB();
}
class Demo18 implements InterA{
    public void printA(){
        System.out.println("printA");
    }
    public void printB(){
        System.out.println("printB");
    }
}

09.19 面向对象（抽象类和接口的区别）
  A.成员区别
　　抽象类：
　　　　成员变量：可以变量也可以常量
　　构造方法：有
　　成员方法：可以抽象，可以非抽象
　　接口：
　　　　成员变量：只能常量
　　成员方法：只能抽象
  C.设计理念：
　　抽象类：体现的是：“is a”
　　接口 ： 体现的是：“like a”
09.20 面向对象（猫狗类）
  A.案例演示<猫狗类>
　　动物类: 姓名 年龄 吃饭 睡觉
　　猫和狗
　　动物培训接口:跳高

package day09;
public class day09_20 {
    public static void main(String[] args) {
        Cat20 c = new Cat20("加菲猫",20);
        c.eat();
        c.sleep();
        System.out.println("-------------------");
        JumpCat jc = new JumpCat("调高猫",30);
        jc.eat();
        jc.sleep();
        jc.jump();
    }
}
/*A.案例演示<猫狗类>
    动物类: 姓名 年龄 吃饭 睡觉
    猫和狗
    动物培训接口:调高*/
abstract class Animal20{
    private String name;
    private int age;

    public Animal20(){}
    public Animal20(String name,int age){
        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();              //1.抽象方法必须放在抽象类种
    public abstract void sleep();  
} 

interface Jumping{                        //实现一个接口
    public void jump();
}
//用猫继承动物
class Cat20 extends Animal20{
    public Cat20(){}
    public Cat20(String name,int age){
        super(name,age);
    }
    
    public void eat(){                      //2.必须重写父类的抽象方法
        System.out.println("Cat eat");
    }
    public void sleep(){
        System.out.println("sleep");
    }
}

//跳猫JumpCat先继承Cat20后继续Jumping 
class JumpCat extends Cat20 implements Jumping{
    public JumpCat(){}
    public JumpCat(String name,int age){
        super(name,age);
    }
    
    public void jump(){                    //3.必须重写 接口中的方法
        System.out.println("猫跳高");
    }
}