类的继承（基本概念、子类对象实例化、super关键字、限制子类访问、复写）

1、继承的基本概念

子类继承父类中的内容，子类可以继续用父类中的内容

继承格式：

class 父类{  } //定义的父类

class 子类 extends 父类{  } //用extends关键实现类的继承

注意：在Java中不可以多项继承，只能单向继承，可以多层继承（如：a可以继承b,b可以继承c;）

public class j1 {
      String name; 
      int age;
}
 
public class j2 extends j1 {
        String city;
}

public class j3 {
    public static void main(String[] args) {
        j2 a=new j2();
        a.name="栋栋";//访问j1中的name属性
        a.age=18;//访问j1中的age属性
        a.city="上海";//访问j2中的city属性
        System.out.println("我叫"+a.name+",今年"+a.age+"岁，住在"+a.city);
    }

}

2、子类对象的实例化过程

子类对象在实例化时，会先调用父类的无参构造方法，之后再调用本类中的相应构造方法

注意：父类中有带参构造方法时，需要再写一个什么都不做的构造方法，否则实例化子类时找不到父类中的无参构造方法，程序会出错。

public class j1 {
      String name; 
      int age;
      public j1(){//无参构造方法
          
      }
      public j1(String n,int a){
          name=n;
          age=a;
      }
}

public class j2 extends j1 {
        String city;
        public  j2(){
            
        }
}

public class j3 {
    public static void main(String[] args) {
        j2 a=new j2();
        
    }

}

3、super关键字的使用

super的主要功能是完成子类调用父类中的属性和方法

 super调用父类的构造方法，只能放在程序第一行。

public class j1 {
    String name;
    int age;

    public j1(String n, int a) {
        name = n;
        age = a;
    }
}

public class j2 extends j1 {
        String city;
        public  j2(){
            super("dongdong",18);//调用父类中的构造方法
        }
}

public class j3 {
    public static void main(String[] args) {
        j2 a=new j2();
        
        a.city="上海";//访问j2中的city属性
        System.out.println("我叫"+a.name+",今年"+a.age+"岁，住在"+a.city);
        
    }

}

super调用父类属性或方法

super.父类中的属性;

super.父类中的方法();

public class j1 {
    String name;
    int age;
    public j1(){}
    
    public String talk(){
        return "我是"+name+",今年"+age;
    }
}

public class j2 extends j1 {
        String city;
        public j2(String n, int a,String c) {
            super.name = n;
            super.age = a;
            System.out.print(super.talk());
            this.city=c;
        }
        
}

public class j3 {
    public static void main(String[] args) {
        j2 a=new j2("dongdong",18,"上海");
        System.out.println("在"+a.city);
    }
}

4、限制子类访问

public class j1 {
   private    String name;
   private    int age;
    public void setName(String name){
        this.name =name;
    }
    public void setAge(int age){
        this.age =age;
    }
    public String talk(){
        return "我是"+this.name+",今年"+this.age;
    }
}

public class j2 extends j1 {
      public void setVar(){
          //访问父类中的封装属性
          super.setName("dongdong");
          super.setAge(18);
      }        
}

public class j3 {
    public static void main(String[] args) {
        j2 a=new j2();
        a.setVar();
        System.out.println(a.talk());
    }
}

5.复写

定义：当一个子类继承一个父类，子类中的方法与父类中的方法名称、参数个数、类型完全一致时，就是子类复写父类的方法；子类中重复定义了父类中已有的属性，就是子类复写         父类的属性

方法的复写格式：

class Super{

访问权限 方法返回值类型 方法1(参数){ }

}

class Sub extends Super{

访问权限 方法返回值类型 方法1(参数){ }//复写父类中的方法

}

注意：子类复写父类的方法时，被子类复写多的方法不能有比父类更严格的访问权限。

在子类可以通过supper.方法()的方式调用父类中被子类复写的方法。

public class j1 {
    String name;
       int age;
    
    public String talk(){
        return "我是"+this.name+",今年"+this.age;
    }
}

public class j2 extends j1 {
        String city;
        public j2(String n, int a,String c) {
            name=n;
            age=a;
            city=c;
        }
        //复写父类中的方法
        public String talk(){
            return super.talk()+city;//使用super。方法()调用父类中被子类复写的方法
        }
}

public class j3 {
    public static void main(String[] args) {
        j2 a=new j2("dong",18,"西安");
        System.out.println(a.talk());//调用的是子类中的方法
    }
}