菜鸟学Java笔记day2

1，继承（extends）

子类 extends 父类，通过继承，子类就拥有了父类所有的成员（包括变量和方法）。Java只支持单继承，不允许多继承，即一个子类只能有一个父类，一个父类可以派生出多个子类。Java通过接口实现类似于多继承特点。

       可以说，子类比父类大，new一个子类时，子类对象包含了一个父类对象(包含了父类的成员对象)和自己的成员变量。

 

2，访问权限

       可以修饰类的成员变量，也可以修饰class。Java中有以下四个访问权限符：

       1)    private，最严格的访问控制，只有所属类的成员才可以访问到private变量。父类的private变量也会被子类全部继承，但是不能访问它（即有所有权，但无使用权。

       2）  default，默认权限（也叫包权限），属于同一个包的成员可以访问到defalult成员变量，在修饰一个变量为默认权限时，不需要写出default。

       3）  protected，受保护的（不是公开开放的），同一个包中的其他类可以访问，同时，子类也可对其进行访问。

       4）  public，所修饰变量在任何地方都可以访问到。

       对于class的权限修饰只可以用public和default，public类可以在任意地方被访问，default类只可以被同一个包内部的类访问。

 

3，重写（OverWrite）

       子类可以根据需要，对从基类中继承来的方法进行重写，重写方法必须和被重写的方法具有相同的方法名称、参数列表和返回类型，重写方法不能使用比被重写方法更严格的访问权限。有如下示例：

public class OverWrite{ 
    public static void main(String[] args){ 
         
        Person person = new Person(); 
        Student student = new Student(); 
         
        person.setName("none"); 
        person.setAge(100); 
        student.setName("Jobs"); 
        student.setAge(24); 
        student.setSchool("XXU"); 
        System.out.println(person.getInfo()); 
        System.out.println(student.getInfo()); 
    } 
} 
 
class Person{ 
    private String name; 
    private int age; 
     
    public void setName(String name){this.name = name;} 
    public void setAge(int age){this.age = age;} 
    public String getName(){return name;} 
    public int getAge(){return age;} 
    public String getInfo(){ 
        return "name: "+name+"\n"+"age: "+age; 
    } 
} 
 
class Student extends Person{ 
     
    private String school; 
     
    public String getSchool(){return school;} 
    public void setSchool(String school){this.school = school;} 
    //重写父类的getInfo()方法，添加了学校显示 
    public String getInfo(){ 
        return "Name: "+getName()+"\nage: "+getAge()+"\nschool: "+school; 
    } 
} 

       上述代码的内存分析如下图所示：栈内存中的彩色变量在成员方法执行完毕后被擦掉。

4，super关键字

       使用super关键字引用基类的成分。this是当前对象的引用，super是当前对象的父类对象的引用。在new一个子类对象的时候，在内存中，这个子类对象会包含一个父类对象。同时也会有一个this引用，指向对象自身；还有一个super引用，指向当前对象的父对象。代码示例：

 

class Father{ 
    public int value;               //若把public 改为private，则Child类将无法访问到 
    public void printValue(){ 
        value = 100; 
        System.out.println("Father's Value: "+value); 
    } 
} 
 
class Child extends Father{ 
    private int value; 
    //重写父类的printValue()方法，并调用父类的该方法 
    public void printValue(){ 
        super.printValue();     //调用父类方法：super.方法名() 
        value = 101; 
        System.out.println("Child's Value: "+value); 
        System.out.println(value); 
        System.out.println(super.value);        //调用父类变量：super.变量名 
    } 
} 
 
public class SuperTest{ 
    public static void main(String[] args){ 
        Child c = new Child(); 
        c.printValue(); 
    } 
} 

内存分析图如下： 

 

 

5，继承中的构造方法

       子类对象构造之前必须要调用父类的构造方法，也就是先构造父类对象。用super(参数列表)调用父类的构造方法，用this(参数列表)调用自己的构造方法。注意：如果调用super()，则super()必须写在子类构造方法的第一行。若子类的构造方法中没有显示调用父类构造方法，则系统自动调用父类无参构造方法，若父类中没有无参构造方法，则出错。