java继承机制

1 继承  关键字：extends   java没有多重继承

实例

父类：

package unit4;

public class Base {
    public int publicVarofBase=1;
    private int privateVarofBase=1;
    int defaultVarofBase=1;
    protected void methodOfBase() {
        System.out.println("执行父类的方法");
    }

}

子类：

package unit4;

public class Sub extends Base{
    public void methodOfSub() {
        System.out.println("执行子类的方法");
        publicVarofBase=2;
        defaultVarofBase=2;
        privateVarofBase=2;
        methodOfBase();
    }
    public static void main() {
        Sub sub =new Sub();
        sub.publicVarofBase=3;
        sub.privateVarofBase=3;
        sub.defaultVarofBase=3;
        sub.methodOfSub();
        sub.methodOfBase();
    }
}

继承的说明：

子类可以继承父类的东西：

1.当子类和父类在同一个包中时，子类继承父类的：public、protected、默认 访问级别的成员变量和成员方法。

2、当子类和父类在不同的包时，子类继承父类：public、protected 访问级别的成员变量和成员方法。

所有的类都直接或间接的继承了java.lang.Object类。

super关键字

super关键字代替匪类对象，通过super可以访问被子类覆盖了的方法或隐藏了的属性。

在一下情况一般会用super关键字：

1 在类的构造方法中，通过super语句调用这个类的父类的构造方法

2 在子类中访问父类的被屏蔽的方法和属性

注意：在子类的构造方法中通过super（）条用父类的构造方法，则此调用必须出现在子类构造方法可执行语句的第一句。

如果没有明确地调用父类的构造方法，编译器会自动加一条调用匪类的默认构造方法，所以一般建议对每一个类都给一个默认的构造方法。

方法覆盖和属性隐藏

package unit4;

public class SuperClass {
    int a;
    public SuperClass() {
        // TODO Auto-generated constructor stub
        a=10;
    }
    public void printA() {
        // TODO Auto-generated method stub
        System.out.println("父类中的A:"+a);

    }

}

package unit4;

public class SubClass extends SuperClass {
int a;
public SubClass(int a) {
// TODO Auto-generated constructor stub
this.a=a;
}
public void printA(){
System.out.println("父类中的A:"+super.a);
System.out.println("子类中的A:"+a);
}

}

package unit4;

public class OverrideDemo {
public static void main(String[] args) {
SuperClass c1=new SubClass(20);
c1.printA();

}

}

父类中的A:10
子类中的A:20

package unit4;

public class Base {
    String var ="Base's Variable";
    void method(){
        System.out.println("call Base's method");
    }

}

package unit4;

public class Sub extends Base{

String var ="Sub's variable";
void method(){
System.out.println("Sub's method call");
}
void test(){
String var = "local variable";
System.out.println("var is "+ var);
System.out.println("this .var is "+ this.var);
System.out.println("super.var is "+super.var);
method();
this.method();
super.method();
}
public static void main(String[] args) {
Sub sub =new Sub();
sub.test();
}
}

var is local variable
this .var is Sub's variable
super.var is Base's Variable
Sub's method call
Sub's method call
call Base's method

java继承中注意：

1 构造方法不能被继承

2 private类型的成员变量和成员方法不能被继承

3 覆盖方法时不能缩小父类方法的访问权限，但可以扩大

4 覆盖方法时不能抛出比父类方法更多的异常

5 不能将静态方法覆盖为非静态方法，也不能将非静态方法覆盖为静态方法

6 由于私有方法不能继承，所以不存在覆盖问题。

final关键字、abstract关键字

final关键字

修饰的类不能被继承，派生子类

修饰的方法不能被重写

修饰的变量不允许修改

abstract关键字

abstract可以修饰类和方法，分别成为抽象类和抽象方法

抽象类相当于一个半成品，需要子类继承并覆盖其中的抽象方法，这样子类才能创建实例

抽象方法没有实现代码，由子类实现。

使用规则：

1 抽象类中可以没有抽象方法。不管类定义时有没有abstract关键字修饰，只要包含了抽象方法，就自动变为抽象类。

2 没有抽象的构造方法，也没有抽象的静态方法

3 抽象类和抽象方法不能被final修饰符修饰，但是抽象类可以包含final方法

inerface关键字和接口

java的接口中只存在公有抽象的方法和公有静态的常量。

不管是否明确添加相应的修饰符，java编译器都会自动给加上相应的修饰符。

接口可以继承，并且可以多重继承。

通过implements声明自己实现了一个或多个接口

package unit4;

import com.sun.java_cup.internal.internal_error;

interface Computable {

    int M=10;
    int f(int x);
    public abstract int g(int x,int y);
}

package unit4;

import com.sun.java_cup.internal.internal_error;

public class A implements Computable {

    public int f(int x){return M+2*x;}
    public int g (int x,int y){return M*(x+y);}

}

package unit4;

public class B implements Computable{
    public int f(int x){return x*x*x;};
    public int g(int x,int y){return x*y*M;}

}

package unit4;

import sun.net.www.content.image.gif;

public class interfacedemo {
    public static void main(String[] args) {
        A a=new A();
        B b =new B();
        System.out.println(a.M);
        System.out.println(" "+a.f(20)+", "+a.g(12,2));
        System.out.println(b.M);
        System.out.println(" "+b.f(20)+" "+b.g(12,2));
    }

}

接口中所有的方法必须是抽象的，接口中的方法定义默认为public abstract类型的，接口中的成员变量的类型默认为public static final。

接口与抽象类之间的区别：

1 抽象类可有构造方法

2 抽象类中可有普通的成员变量

3 抽象类中可有非抽象的普通方法

4 抽象类中可有静态的方法

5 抽象类中的静态成员变量类型可以任意，接口中的只能是public static final型

6 一个类可以实现多个接口，但是只能继承一个抽象类