继承 super 抽象 接口 多态

程序中想声明一个类去继承另一个类,使用的是  extends 关键字 

下面三个类是可以写在一起的,只需要用一个public修饰即可


1. 创建父类模板 pen
 class pen {
    private String name;
    private int  age = 100;

     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;
     }
 }


 class kali extends pen{
    // 子类中设置属性肯定也是定义属性
    private String  color;

     public String getColor() {
         return color;
     }
     public void setColor(String color) {
         this.color = color;
     }
 }

3. 继承后我们单独再新建一个类 把 kali  new出使用 

public class saber {
    public static void main(String[] args) {
        // 创建继承之后的子类 看看是否可以使用父类的属性和行为
        kali k = new kali();  
        k.setName("世界");
        k.setAge(18);   // 使用的是父类的属性
        k.setColor("黑色")  //使用的是子类属性
        System.out.println("姓名是"+k.getName()+"年龄是"+k.getAge()+"颜色是"+getColor() );
    }
}


--------------------------------------------------
输出:姓名是世界年龄是18 颜色是 黑色

实例代码

// 定义 a子类并写入 le成员方法
class  a{
    void  le(){
        System.out.println("你好啊");
    }
}

// 定义 b子类 继承上方的 a子类  这个时候b可以使用a的东西
class b extends a{
    void le(){   // 再次定义le方法 修改参数,这就是方法的重写
        System.out.println("世界啊");
    }
}

public class jk {
    public static void main(String[] args) {
        b boo = new b();  //  实例化b类 
        boo.le();  // 使用b类重写后的le方法 会输出
    }
}

----------------------------

输出: 世界后 重写成功

实例代码

  class  a{
      public void  le(){ //父类的代码宽松
          System.out.println("你好啊");
      }
  }
  
  class b extends a{
      private void le(){  // 子类重写的更严格这样是不行的
          System.out.println("世界啊");
      }
  }
  
  public class jk {
      public static void main(String[] args) {
          b boo = new b();  
          boo.le();  
      }
  }
---------------------------------------
以上写法会报错,因为子类重写父类的方法,是不能比他更加严格的,
但相反是可以比他更加松懈 

class  a{
    private void  le(){  // 父类的严格
        System.out.println("你好啊");
    }
}
class b extends a{
    public void le(){    // 子类的更宽松这样是可以的
        System.out.println("世界啊");
    }
}

public class jk {
    public static void main(String[] args) {
        b boo = new b();
        boo.le();
    }
}

---------------------------------------

输出: 世界啊

super.成员变量
super.成员方法(参数1,参数2)

实例代码

class  a{
    String name = "柴犬"; // 父类的name
     void  le(){         // 父类的方法
        System.out.println("你好啊");
    }
}
class b extends a{  // 子类b 继承 父类
    public void le(){
      super.le();  // super调用父类的le方法 会输出    第一个输出
      System.out.println("重写后的世界");  // 第二个输出
    }
    public void lon(){
        System.out.println("全部都是"+super.name); // 通过super关键字调用 父类的name  //第三个输出
    }
}

public class jk {
    public static void main(String[] args) {
        b boo = new b();
        boo.le();
        boo.lon();
    }
}

--------------------------------------------
super的用法就是继承后方便子类调用父类的属性,前提是二者是一个继承关系

输出: 

你好啊
重写后的世界
全部都是柴犬 

class  a{
    private String name ;
    private  int 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 a(String name, int age){     // 父类的构造方法  One 
        this.name =name;
        this.age = age;
    }
    public void info(){  // 父类的方法
        System.out.println("名称是"+this.getName()+"年龄是"+this.getAge());
    }
}
class b extends  a{
  private String color;
  //  b 类的构造方法 使用了父类 a的成员属性 因为继承过来了 
     public b(String name, int age, String color) { // 传入的值一次性可以有三个  // 
        super(name, age);   //  super使用了父类的构造方法  One 把值拿到 
        this.setColor(color); //  拿到本类中定义的属性 color的值通过 setColor       才有了这个  2 

    }
    public String getColor() { // 封装后的方法   有了这个  1 
        return color;
    }

    public void setColor(String color) {  // 封装后的方法
        this.color = color;
    }
    // 重写父类的 info 方法
    public void info(){
        super.info();  //调用 父类的info方法a类的,  this.getColor() 完全是由用户自控制的
        System.out.println("颜色是"+this.getColor()); // 对应最后一句’
        
    }
}


public class jk {
    public static void main(String[] args) {
        b boo = new b("柴犬",18,"黄色");  // 传入值到 构造方法中,里面会有三个值,name age 是父类a的 只有color是子类b自己
        boo.info();                     // 传入的子类的值由   this.setColor(color);
    }
}

----------------------------------------------------
  输出:
名称是柴犬18 颜色是黄色  
实例化调用子类的方法的话,我们在子类中也写入了 super.info()  会先调用父类的方法下方也有子类的方法, 两者才可以一起执行

// final 关键字修饰 类

final class  a{
  public  void saber(){
      System.out.println("不可以被继承");
  }
}
class Dog extends  a{  // 不可以被继承会报错  提示  被final修饰的类不可继承

}



public class independence {
    public static void main(String[] args) {
        System.out.println("123");
        Dog  D = new Dog();
        
    }
}

------------------------------------
编译报错,被final修饰的类不可被继承

class  a{
  public  final void saber(){
      System.out.println("不可以被继承");
  }
}
class Dog extends  a{
  // 继承后尝试重写父类 a 的saber方法
    public void  saber(){
        
    }

}



public class independence {
    public static void main(String[] args) {
        System.out.println("123");
        Dog  D = new Dog();

    }
}

----------------------------------------------
编译报错 被final修饰的方法不能被重写 会成为最终的方法,如果在父类中定义某个方法,如果不希望被子类重写 那么就可以使用final关键字修饰

被final修饰的变量最终会成为常量 也就是不能被修改,常量只能在被声明时赋值一次,后面如果再修改就会报错

public class independence {
    public static void main(String[] args) {
        final  int a = 100;
        a = 200;

    }
}


------------------------------
编译报错,在对 a 变量进行二次赋值编译器报错。 被final修饰的变量不能修改。

abstract 返回值类型 方法名称(参数);

abstract class  kami{ // 抽象类

    public void  saber(){}  // 普通方法
    public  abstract  void min(); //  抽象方法无方法体  访问权限 abstract 访问类型 方法名称(参数)
}

public class Quadratic {
    public static void main(String[] args) {

    }
}

抽象类比普通类多了一些抽象方法,其他地方比普通类组成相同

 abstract class  kami{

    public void  saber(){}  // 普通方法
      public abstract  void min(); //  抽象方法无方法体
}
class Dog extends  kami{  
    // 实现使用 min  抽象类的min方法  非抽象的类继承了父类那么父类中的
    public void min(){
         System.out.println("完美世界");
     }
}

public class Quadratic {
    public static void main(String[] args) {
    Dog k  =  new Dog();  // 创建继承后的实例对象 k
    k.min();  // 调用Dog对象的min方法

    }
}


--------------------
输出:  
完美世界

错误的方法 

prvate viod saber(){} 

public interface 接口名 extends 接口1 接口2 {
     public static final 数据类型 常量名 = 常量值;   // final修饰的变量是最终的不可修饰
     public abstract 返回值类型 抽象方法名称 (参数列表);   // 抽象方法
}

接口中的变量默认使用  public stactic final  修饰即全局变量

接口中定义的方法默认使用   public abstract  修饰即抽象方法 

如果接口的访问权限声明为public 则接口里面的变量和方法都是public权限

修饰符 class 类名 implements 接口1,接口2{

}

定义接口 Animal

interface  Animal{
    int id = 1;  // 接口里面的变量默认是全局变量
    String  name = "左翼";
    void  shout();    // 抽象方法
    void  info();     // 抽象方法
    static void getId(){  // 静态方法
        System.out.println(Animal.id);
    
//    static int getId(){
//        return Animal.id;
//    }
}

// 定义接口 Action
interface  Action{
    void eat();    // 抽象方法
}


// 定义 other 类实现 Animal Action 接口
class other implements Animal ,Action{
    // 重写方法 2个接口里面的全部方法
    public void shout(){
        System.out.println("Action是行为的意思");
    }
    public void  info(){
        System.out.println("信息是大学生");
    }
    public void eat(){
        System.out.println("世界阿"+name);
    }
}

public class Quadratic {
    public static void main(String[] args) {
         //  Animal.getId();  通用的方式
        // 这里出现了两种情况,如果方法没有返回值是void的形式那么就可以直接 接口.方法名    
        // 这种方式调用是通用的,只是return是没有打印语句,所以如果是return的情况那么就需要利用下面的形式把调用语句放在打印里面输出
        System.out.println("编号是"+Animal.getId());  //接口.方法名 调用
        
        System.out.println(Animal.id+"是天气");// 接口直接访问常量
        other Student = new other(); // 实例化拿到对象
        Student.shout();  // 调用重写的方法
        Student.info();
        Student.eat();
    }
}

实例化对象可以直接访问接口中的常量、重写的接口方法和本类内部方法,而接口中的静态则可以直接使用接口名调用
接口的实现类必须实现  implements  接口全部的方法,接收到多少实现多少, 否则会报错

---------------------------------------------
输出:
  编号是1
  1是天气
  Action是行动的意思
  信息是大学生
  世界阿左翼

修饰符 class 类名 extends 父类名 implements 接口1,接口2 {

}

// 定义接口 Animal

interface  Animal{
    int id = 1;  // 接口里面的变量默认是全局变量
    String  name = "左翼";
    void  shout();    // 抽象方法
    void  info();     // 抽象方法
}

// 定义抽象类
abstract class repeat{
    public abstract void saber(); // 定义抽象方法
}


// 定义 other 类实现 Animal接口 并且继承 repeat抽象类,二者兼得
class other extends repeat  implements Animal  {
    // 重写接口中的两个方法
    public void shout(){
        System.out.println("");
    }
    public void  info(){
        System.out.println("信息是大学生");
    }
    // 普通的方法
    public void eat(){
        System.out.println("世界阿"+name);
    }
   // 重写抽象类中的方法
    public void saber() {
        System.out.println("saber是大美女");
    }
}

public class Quadratic {
    public static void main(String[] args) {
        other Student = new other(); // 实例化拿到对象
        Student.eat();  // eat方法是我们自己加入的方法调用
        Student.info();  // 调用重写的方法
        Student.shout();
        Student.saber();
    }
}

 other 类通过exthds继承了  repeat 抽象类,并且 implements 实现了 Animal  接口。 因为接口和抽象类本身都存在抽象方法, 所以other类必须重写
 Animal 接口和  repeat 抽象类 

-----------------------------------------------
输出:

世界阿左翼
信息是大学生
你好
saber是大美女

interface Action extends Animal,Color{
    void shout();
}

// 定义接口 Animal

interface  Animal{
    int id = 1;  // 接口里面的变量默认是全局变量
    String  name = "左翼";
    void  info();     // 抽象方法
}

// 定义Color接口
interface  Color{
    void black();  // 抽象方法
}

//  定义接口继承上面接口
interface Action extends Animal,Color{
    void shout();
}


// 定义 other 类实现 Animal接口 并且继承 repeat抽象类,二者兼得
class other  implements Action  {
    // 重写 Animal接口方法
    public void info(){
        System.out.println("你好");
    }
    // 重写Color接口方法
    public void  black(){
        System.out.println("黑色");
    }
   // 重写Action接口方法
    public void shout() {
        System.out.println("saber军刀");
    }
}

public class Quadratic {
    public static void main(String[] args) {
        other Student = new other(); // 实例化拿到对象
        // 调用重写的方法
        Student.info();
        Student.shout();
        Student.black();

    }
}

Action 接口继承了上面两个接口,这样Action接口就可以拥有上面两个接口的抽象方法还有本类 shout方法  
而后利用other类实现接口,再实例化类这样Student对象就需要重写这三个抽象方法

-------------------------------------------------------------
输出:  
     你好
     saber军刀
     黑色

实例代码

// 定义抽象类 Animal
abstract  class  Anima{
    abstract  void  shot(); //抽象方法 shot
}
// 被两次不同类继承所以要实现两次,同一个对象被不同的类继承 所重写表现的就是多态
class Cag extends  Anima{
    // 实现 shot方法,因为继承所以需要被实现
    public void shot(){
        System.out.println("master是你吗围巾");
    }
}
class kli extends  Anima{
      public  void  shot(){
          System.out.println("秋天到了");
      }
}
public class op{
    public static void main(String[] args) {
        Anima sa = new Cag(); // 创建Cat对象使用Anima类型变量 ,也就是被父类变成了一种类型 使用父类去调用子类的方法 
        Anima sa2 = new kli();
        sa.shot();
        sa2.shot();
    }
}


------------------------------------------
输出:

master是你吗围巾
秋天到了

实例代码

// 定义类 Animal
  class  Anima{
    public   void  shot(){ // 普通方法
        System.out.println("你好");
    }
}
class Cag extends  Anima{
    //  重写 shout() 方法
    public void shot(){
        System.out.println("master是你吗围巾");
    }
    public void eat(){
        System.out.println("吃骨头");
    }
}
public class op{
    public static void main(String[] args) {
        Cag dog = new Cag(); // 创建Dog对象
        Anima an = dog;
        //向上转型将实例化后的 dog  又重写给了父类Anima 那么父类可以使用 ad.方法() 调用
        an.shot();  // 虽然是使用父类类型,但调用的还是之后被子类重写的方法 
    }
}

--------------------------------------
输出:

master是你吗围巾
 
 
 注意: 

 对象即使发生了向上转型关系后,所调用的方法一定是被子类重写的方法 
 并且只能调用父类和子类共同都有定义的方法,二者都需要存在,上例中 an父类对象是无法调用 eat()方法的
因为eat() 方法未在父类Anima中定义只在子类中定义

实例代码

// 定义类 Animal
  class  Anima{
    public   void  shot(){ // 普通方法
        System.out.println("你好");
    }
}
class Cag extends  Anima{
    //  重写 shout() 方法
    public void shot(){
        System.out.println("master是你吗围巾");
    }
    public void eat(){
        System.out.println("吃骨头");
    }
}
// 转换格式

 1.父类类型 父类对象 = 子类实例

2.子类类型  子类对象 =  (子类) 父类对象 

public class op{
    public static void main(String[] args) {
       Anima an = new Cag(); //1. 第一步先发生向上转型 将Cag()的实例转换成了类Anima()的实例
       Cag dog = (Cag) an; // 2. 向下转型  将Anima类的实例转换成 Cag类的实例,对应上方两步操作
       dog.shot();
       dog.eat();
    }
}

----------------------------------------------
输出: 

master是你吗围巾
吃骨头

 注意:  

调用的仍是子类的方法,因为父类的方法已经被子类重写,可以调用子类里面的任何方法 不需要父类中定义
这里和向上的区别就出现了, 如果我没有理解错的话,向上转型后只能调用两者共有的,向下转型只要是子类的方法都可以调用、 


向下转型不能直接将父类实例对象转换为子类实例,也就是一步到位这是不允许的,否则报错。以下情况是不可以的
不理解就看括号

 Cag dog = (Cag) new Anima(); 

1.父类类型 父类对象 = 子类实例

2.子类类型  子类对象 =  (子类) 父类对象

实例代码

// 定义类 Animal
  class  Anima{
    public   void  shot(){ // 普通方法
        System.out.println("你好");
    }
}
class Cag extends  Anima{
    //  重写 shout() 方法
    public void shot(){
        System.out.println("master是你吗围巾");
    }
    public void eat(){
        System.out.println("吃骨头");
    }
}
public class op{
    public static void main(String[] args) {
      Anima a1 = new Cag(); // 向上转型 实例化对象是Anima
     // 两个都是属于 父类Anima Cag也是它的子类,所以 a1 对象是下面两个类的实例
     System.out.println("Amima a1 = new Dog():"+(a1 instanceof Anima)); // 真
     System.out.println("Amima a1 = new Dog():"+(a1 instanceof Cag)); // 真

     Anima a2 = new Anima(); // 普通实例化与子类没有关系 
     System.out.println("Amima a1 = new Dog():"+(a2 instanceof Anima));  // 真
     System.out.println("Amima a1 = new Dog():"+(a2 instanceof Cag));// 假
    }
}
 
注意:   
    观察父类是否发生转型即可,发生转型的话那么子类实例化的对象也是属于父类的