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：接口不能有构造 – 因为不能有任意的实例体所以不能有构造