Java基础_07

1：继承与构造方法

 

Child c = new Child();

 

要想建立子类，则必须先建立父类。

当建立子类的实例时，会先调用父类的构造方法，将这个类的字节码加载到内存中。

 

package cn.demo;

import org.junit.Test;

 

public class Demo01 {

    @Test

    public void test1(){

        Grandpa g = new Child();   //父类的变量指向子类的实例  回首先调用父类的构造方法

//在此处是child—father-grandpa

 

    }

}

class Grandpa {

    public Grandpa() {

        System.err.println("Grandpa..."+this);//this永远是指new的对象内存地址值，即引用

    }

}

 

class Father extends Grandpa {

    public Father() {

        System.err.println("Father.."+this);

    }

}

 

class Child extends Father {

    public Child() {

        System.err.println("Child.."+this);

    }

}

输出：

Grandpa...cn.demo.Child@514713

Father..cn.demo.Child@514713

Child..cn.demo.Child@514713

 

说明：

   1：实例化子类时，会先调用父类的默认的构造方法。即先会加载父类。

   2：此时在任意的位置(非静态的方法)中使用的this表示的是new的那个对象。

2：Super关键字 – 与this同样只能用于非静态的方法中

用法1：

   调用被隐藏的成员变量。

   调用被重写的成员方法。

class Grandpa {

    public String name = "Grandpa";

    public void say(){

        System.err.println("name is:"+name);

    }

}

 

class Father extends Grandpa {

    public String name = "Father";//若是子类的成员变量与父类的成员量重名，此时父类的成员变量叫被隐藏了    //重写

    @Override

    public void say() {

        System.err.println("father name is:"+name);//Father name is : Father

        //若是但愿访问父类的成员变量则能够在非静态的方法里面使用super关键字

        System.err.println("grandpa is :"+super.name);//Grandpa is Grandpa

        //固然也能够调用父类被重写的方法

        super.say();//name is grandpa

    }

}

输出：

father name is:Father

grandpa is :Grandpa

name is:Grandpa

 

用法2：

  在子类的构造方法的第一句调用父类的某个构造。

class One {

    public One(String name) {

    }

}

 

/**

 * 当父类没有默认构造时 若是实例化子类，子类又要调用父类的默认的构造 由于父类又没有默认的构造，因此子类出错

 * 此时，子类必需要手工的添加一个任意的构造，且在构造方法的第一句 显式调用父类的某个有参数的构造

 */

class Two extends One {

    public Two() {//在子类的构造中，必需要调用父类的某个构造

        super("Jack");//

    }

    public Two(String nnm){

        super("Mary");

    }

}

3：final关键字

修饰的对象	功能	示例：
能够修饰局部变量     当修饰局部变量 若是局部变量是数组则整个的数组不能再指向新的地址，可是里面的值是能够修改的：	这个变量不能再指向新的地址
能够修饰成员方法   当修饰非静态的方法时，说明这个方法子类不能重写。		public class Demo03 {     @Test     public void test1(){         ATwo t = new ATwo();         t.say();//只能调用父类的     } }   class AOne{     //此方法是最后的，不能被子类重写     public final void say(){         System.err.println("ddddd");     } } class ATwo extends AOne{ }
Final能够修饰类    表示这个类不能有子类

Fnal能够修饰：

  成员变量

  局部变量

  类

  成员方法。

[

         其余的所修饰符号，能不修改局部变量，只有final能够修饰局部变量。

}

4：final与private

Final修饰的类不能有子类,可是能够被实例化。

 

用private修饰的构造，不能拥有子类，也不能够被实例化.

5：抽象类

 

抽象关键字是： abstract 。

 

  被abstract修饰类叫抽象类。

   特色：

      1：抽象类不能被new实例化。

                            /**

 * 声明一个抽象类

 */

abstract class Animal{

   

}

如下是错误的;
    new Animal();

 

 

      2：抽象类能够拥有抽象方法

            [抽象方法，是使用了abstract修饰的方法]

            抽象方法不能有方法体：方法后面加上{}即被视为有方法体

               Public abstract void say();

      3:抽象类能够有抽象方法。也能够没有抽象方法。

 

abstract class Animal{

    //此方法是非抽象的

    public void say(){

       

    }

    //抽象

    public abstract void run();

}

    

     4：抽象方法必需要在抽象类里面。   

 

 

     5:当一个类继承抽象类时，必需要实现（重写）全部父类中的抽象方法

 abstract class Animal{

    //此方法是非抽象的

    public void say(){

       

    }

    //抽象

    public abstract void run();

    public abstract void hi();

}

 

class Dog extends Animal{  

    @Override

    public void run() {

    }

 

    @Override

    public void hi() {

    }

}

   5：抽象类能够拥有构造方法。

  

 

说明：

  抽象类，就是用于让子类继承的。

  要求子类必需要实现某些方法，【定义的些规范】

 

 

限制：

   Abstract关键字：不能修饰成员变量。只能修饰成员方法与类。

   Abstract不能与private共同使用。不能与static共同使用。不能与final共同 。

 

小结：

  抽象类就是被abstact修饰的类。此类不能被实例化。

  被abstract修饰的方法，就抽象方法，不能有方法体系，必需要在抽象类里面。

6：接口

接口是被

   Interface声明的类。

interface IOne{

   

}

 

2：也不能被实例化。

   New Ione();错误的。

 

3：接口中的全部方法，默认都是：

     Public abstract的

 

interface IOne{

    public abstract void say();

}

 

4:里面的全部成员变量默认都是

   Public static final的 – 静态常量 ，必需要声明时或在static代码块中设置值

interface IOne{

    public static final int AGE=34;

    void say();

}

 

5：在接口中不能有任何的实现

即

{

   …能够被执行的代码

}

 

6：接口位于类层次的最上层

用于让子实现实现

interface IOne{

    public static final int AGE=34;

    void say();

    void hi();

}

//一个类实现一个接口，也能够实现多个接口

class One1 implements IOne{

    public void say() {

    }

    public void hi() {

    }

}

 

7：一个具体类能够实现多个接口

 interface IOne{

    public static final int AGE=34;

    void say();

    void hi();

}

interface ITwo{

    public void run();

}

//class SomeClass extends 亲爹 implements 叔叔1，姑姑,....

//一个类实现一个接口，也能够实现多个接口

class One1 implements IOne,ITwo{

    public void say() {

    }

    public void hi() {

    }

    @Override

    public void run() {

    }

}

   8：接口不能有构造 – 由于不能有任意的实例体因此不能有构造