Java基础部分第九节（

• 01多态概念：
• 事物存在的多种形态
• 多态的前提
  
  • 要有继承关系
  • 要有方法的重写
  • 要有父类的引用指向之类对象
  • cat c = new cat(); //猫是一只猫，右边给左边赋值
  • c.eat()；——-//猫吃鱼
  • ——
  • animal a = new cat();//父类的引用指向之类对象
  • a.eat();——-//猫吃鱼
    class animal{
    public void eat(){
    system.out.println(“动物吃饭”)
    }
    }
    class cat extends animal{
    public void eat(){
    system.out.println(“猫吃鱼”)
    }
• 02多态的成员访问
• 成员变量：
  
  • 编译看左边（父），运行看左边（父）
    *成员方法
  • 编译看左边（父），运行看右边的方法（子）
• 静态方法
  
  • 编译看做左边，运行看左边
  • 静态和类相关，算不上重写，访问还是走左边

• 只有非静态的方法是>编译看左边，运行看右边
  *
  public class Poy {
  public static void main(String[] args) {
  father f =new son();
  System.out.println(f.num);//10 成员变量：编译看左边（父），运行看左边（父）
  son s = new son();
  System.out.println(s.num);//20
  father f1 = new son();
  //f.print(); //son编译看左边（父），运行看右边的方法（子）
  //动态绑定
  f.method(); //father static method. 编译看做左边，运行看左边
  }
  }
  class father{
  int num =10;
  public void print(){
  System.out.println(“father”);
  }
  public static void method(){
  System.out.println(“father static method”);
  }}
  class son extends father{
  int num =20;
  public void print(){
  System.out.println(“son”);
  }
  public static void method(){
  System.out.println(“son static method”);
  }}

• 03面向对象

• 基本数据类型自动提升，强制转换
  
  • int i=10; byte b =20; i=b; 自动提升
  • b=i;损失精度 b=（byte）i； 强制转换

• 父类引用指向子类就是向上转型
  * person p =new superman();//父类引用指向子类对象，超人提升为人
  * //父类引用指向子类对象就是向上转型
  * superman sm =(superman)p;向下转型 先提升，在强转
  案例：
  public class Test{
  public static void main(String[] args) {
  //cat c =new cat();
  //c.eat();
  method(new cat());
  //method(new dog()); //错误，这样写还需要在定一个方法
  method(new dog());
  }
  /*public static void method(cat c){
  c.eat();
  }
  cat c = new dog（）；狗是一只猫这是错误的
  //如果强制把狗转换成猫就会出现类型转换异常ClasscastException
  public static void method (animal a{
  cat c =(cat)a;
  c.eat();
  c.catchMouse();
  }

  public static void method(dog d){
  d.eat();
  }*/
  //重新写一个方法 //当参数的时候使用多态，拓展性强，做参数，其所有的子类对象都可以传进来
  public static void method(Animal a){
  //父类引用指向子类对象，直接创建子类对象更方便，可以使用子类中的特有属性—-重点

  //关键字instanseof判断前边的引用是不是后边的类型if(a instanceof cat){    cat c =(cat)a;    c.eat();    c.catcahMouse();}else if(a instanceof dog){    dog d=(dog)a;    d.eat();    d.lookHome();}else{    a.eat();}

  }
  }
  class Animal{
  public void eat(){
  System.out.println(“动物吃饭”);
  }
  }
  class cat extends Animal{
  public void eat(){
  System.out.println(“猫吃鱼”);
  }
  public void catcahMouse(){
  System.out.println(“猫抓老鼠”);
  }

  }

  class dog extends Animal{
  public void eat(){
  System.out.println(“狗吃肉”);
  }
  public void lookHome(){
  System.out.println(“看家”);
  }
  }

• 04抽象类

  • abstract class 类名{}
  • public abstract void eat();
  • A:抽象类不一定有抽象方法，有抽象方法的类一定是抽象类或者是接口
  • B:抽象类不能被实例化，由具体的子类去实例化（重写方法)。其实也是多态的一中，抽象类多态

  • D：抽象类的子类

    • 要么是抽象类
    • 要么重写抽象类中的所有抽象方法（开发用这个）
      *抽象类的成员特点
      *1.成员变量，既可以是变量也可以是常量。abstract是否可以修饰成员变量？ —-变量固定不能抽象
      *2.构造方法：有
      *用于子类访问父类数据的初始化
      *3.成员方法：即可以是抽象的也可以是非抽象的
      *成员特点：抽象方法要求子类做的事情
      *非抽象方法 子类继承的事情，提供代码的复用性
      *实例 猫狗
      public class Test_1 {
      public static void main(String[] args) {
      cat c = new cat(“red”,65);
      System.out.println(c.getName()+” “+c.getAge());
      c.eat();
      c.catchMonth();

    dog d =new dog();
    d.setAge(2);
    d.setName(“tidy”);
    System.out.println(d.getName()+”….”+d.getAge());
    d.eat();
    d.lookHome();

  }

  }

  /*猫狗
  共性：姓名，年龄，吃饭
  猫：抓老鼠
  狗：看家
  */
  abstract class animal{
  private String name;
  private int age;

  public animal(){}//空参
  public animal(String name, int age) {//有参
  this.name = name;
  this.age = age;
  }
  public String getName() { //getname
  return name;
  }
  public void setName(String name) {//setname
  this.name = name;
  }
  public int getAge() {//getage
  return age;
  }
  public void setAge(int age) {//setage
  this.age = age;
  }
  public abstract void eat(); //抽象的吃放方法，修给类为抽象类

  }
  class cat extends animal{
  public cat() {}
  public cat(String name,int age){
  super(name,age);
  }
  public void eat(){
  System.out.println(“猫吃鱼”);
  }
  public void catchMonth(){
  System.out.println(“猫抓老鼠”);
  }
  }
  class dog extends animal{
  public dog() {}
  public dog(String name,int age){
  super(name,age);
  }
  public void eat(){
  System.out.println(“狗吃肉”);
  }
  public void lookHome(){
  System.out.println(“狗看家”);
  }
  }

• 05面试题
  
  • 1.一个抽象类如果没有抽象方法，可不可以定义为抽象类？如果可以，有什么意义？
    
    • 可以，目的是不让其他类创建本类对象，交给子类完成
  • 1. abstract 不能和那些关键字共存 （非法的修饰符组和）
       *static 被static修饰的类名可以用.调用，但是类名.调用抽象方法是没有意义的
       *final 被abstracr修饰的子类强制重写，被final修饰的不让重写
       *private 被abstracr修饰的是为了让子类看到并强制重写，被private修饰的不让看到修改
       *06 interface(接口)对外提供规则的都是接口

• 特点：

  • 接口用interface表示
    
    • interface 接口名 {}
  • 实现类接口用implements
    
    • class 类名 implements 接口名 {}
      *接口不能实例化 调用抽象方法没有意义
      *如何实现
      *按照多态的方式实现实例化
      *接口的子类
      *可以是抽象类，但是意义不大
      *可以是具体的类。要重写接口中的所有的抽象方法（开发使用）
      *通过子类进行实例化，父类引用指向子类
      *案例演示
      public class Interface_1 {
      public static void main(String[] args) {
      demo d = new demo();
      d.print(); //10
      System.out.println(inta.num);//10 隐藏public
      }

  }
  interface inta { //接口权限是public
  int num =10; //接口中定义的变量都是常量，默认有final修饰
  //隐藏public，static final 三者没有顺序
  //public void print (){} 接口中不能定义非抽象类，不能有主体
  void print(); //隐藏abstract
  }
  class demo /extends object/implements inta{ //默认继承extends object
  public void print(){
  System.out.println(num);
  }
  public demo(){
  super(); //默认继承extends object,访问object
  }
  }

• 面向对象(抽象类和接口的区别)

  • 类与类，类与接口，接口与接口的关系
    
    • A类与类
      
      • 继承的关系只能单继承，可以多层继承
        *B 类与接口
        *实现关系，可以单实现，也可以多实现（class demo implements interA,interB{},需要重写）
        *并且可以在继承一个类的同时实现多个接口
        *C接口与接口
        *继承关系，可以但继承，也可以多继承 （interface interC extends interB,interA）

*面对抽象，抽象类和接口的区别
1.成员区别
*抽象类–成员变量:可以变量，可以常量
* 构造方法：有
* 成员方法：可以抽象，也可以非抽象
*接口—-成员变量：只可以是常量
* 成员方法：只可以是抽象的
2.关系区别
* 类与类
*继承，单继承
*类与接口
*实现，单实现，多实现
*接口与接口
*继承，单继承，多继承
3.设计理念的区别
*抽象类，被继承体现的是：“is a” 的关系。抽象类中定义的是该继承体系的共性功能。
*接口，被实现的 “like a” 的关系。接口中定义的是该继承体系的拓展功能。
* ———-案例：猫狗，跳高———
public class Test {
public static void main(String[] args) {
cat c =new cat(“tody”,6);
System.out.println(c.getName()+” “+c.getAge());
c.eat();
c.sleep();
System.out.println(“…………”);
jumpcat gc = new jumpcat();
gc.eat();
gc.sleep();
gc.up();
}
}
/*
tody 6
猫吃鱼
侧着睡觉
…………
猫吃鱼
侧着睡觉
猫跳高

 */abstract class animal{    private String name;    private int age;    public  animal(){}                      //空参    public  animal(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();    public abstract void sleep();}interface up{    public void up();}//猫class cat extends animal{    public cat(){}    public cat(String name,int age){    //有参        super(name,age);    }    public void sleep(){        System.out.println("侧着睡觉");    }    public void eat() {        System.out.println("猫吃鱼");    }}class jumpcat extends cat implements up{    //亮点代码    public void up() {        System.out.println("猫跳高");    }}

案例2—-女星认干爹，亲爹只有一个，单继承，干爹很多，多实现
/*
女星认干爹，亲爹只有一个，单继承，干爹很多，多实现
*/
interface 某干爹{
public void 关系();
public void 潜规则();
}
class 某明星 implements 某干爹{
public void 关系(){
System.out.println(“借关系上位”);
}
public void 潜规则(){
System.out.println(“你们懂得”);
}
}