java 中的继承

继承的概念

继承就是子类继承父类的特征和行为，使得子类具有父类得属性和方法。

继承得关键字:extends

语法格式:<modifier> class <name> [extends superclass] {......}

通过继承，子类自动拥有基类(superclass)得所有成员(成员变量和方法)。

java只支持单继承，不允许多继承; 但是c++中允许多继承。

一个子类只能继承一个父类，但是一个父类却可以派生多个子类(一个孩子只有一个爸爸，但是爸爸可以有多个孩子)

简单的例子

/*
 * 父类 Person
 */
class Person {
    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;
    }
    
    
}

/*
 * 子类 Student
 */
class Student extends Person {
    private String school;

    public String getSchool() {
        return school;
    }

    public void setSchool(String school) {
        this.school = school;
    }
    
    
}

/*
 * 测试类
 */
public class Test {
    public static void main(String[] args) {
        Student stu=new Student();
        stu.setName("刘杰");
        stu.setAge(22);
        stu.setSchool("淮阴师范学院");
        
        System.out.println("姓名:"+stu.getName());
        System.out.println("年龄:"+stu.getAge());
        System.out.println("学校:"+stu.getSchool());
        
    }
}

继承在内存中的解析:

Student stu =new Student();

stu 对象的引用，存放在stack中，指向-->new Student();

new Student()因为是new 出来的对象，所以存放在heap中。但是Student是子类，他继承父类Person。Student(子类)包含Stundent(父类)，子类比父类大!!!

内存分析如下所示:

访问控制

java权限修饰符(modifier) public protect private置于类的成员定义或者声明前。

作用:限定其他对象对该类对象成员的访问权限。

package com.Demo;

/*
 * 父类 Person
 */
class Person {
    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;
    }
    
    
}

/*
 * 子类 Student
 */
class Student extends Person {
    private String school;

    public String getSchool() {
        return school;
    }

    public void setSchool(String school) {
        this.school = school;
    }
    
    
}

class Access {
    
    //私有变量安全性更高
    private int i=0;
    
    //default包权限 同一个包里面的class 可以访问其他class类里面的default 变量
    //c++中不存在default 访问权限符
            int j=1;
            
    //受保护  同一个包里面可以访问protect变量，而且该类的子类还可以protect
    protected int z=2;
    public  int y=3;
    
    //public 类型访问类中的私有变量
    public int getI(){
        return i;
    }
}

class AccessOne extends Access {
    
}
/*
 * 测试类
 */
public class Test {
    public static void main(String[] args){
        
        Access a=new Access();
        
        /*
         * AccessOne继承于Access,拥有Access的所有变量成员（包括private）,但是对于private没有使用权限，有访问权限!
         */
        AccessOne a1 =new AccessOne();
        Test t=new Test();
        /* 
         * 报错  i是用private修饰，即使是用Access.i访问也没有任何用。
         *  只能在class Access本身类中用成员方法进行访问，而且定义的方法还要用public进行修饰。
         *  若继续用private还是无法进行访问
         */
        //System.out.println(a.i);  
        
        System.out.println(a.getI());
        
        System.out.println(a.j);
        
        System.out.println(a.z);
        System.out.println(a1.z);
    }
}