Java高级编程3-姜国海

①多态

行为的多样性

表现形式：1.重载，2.覆盖
1.在一个类里面函数名一样，输入参数不一样
    仅仅是返回参数不一样时，不可多态。返回值是可以放弃的，即不可以通过返回值区别不同函数
Eg：
class student{
    water getWater(){
    }
    water getWater(ClassmateReq cr){
    }
    water getWater(TeacherReq tr){
        return null;
    }
}

2.一个类的不同派生类展现出不同的性质

class student {
    public void study() {
    }

}


class LazyStudent extends Student {
    public void study() {
        for(;;){
            sleep();
            eat();
        }

    }

    public static void main() {
        Student s1 = new Student();
        Student s1 = new LazyStudent();//基类的引用可以指向派生类
        s1.study();
        s2.study();
    }
}

Java中除了static 函数之外都是虚函数，只有在运行时才进行动态绑定，
执行速度慢，但是灵活度高

class C {
    final void a() {
    //编译的时候就进行绑定，执行速度快，但是缺乏灵活性
    }
}

②抽象函数


//抽象类里面可以有抽象函数，也可以没有抽象函数，但是有抽象函数的必须是抽象类
abstract  class A {
    abstract void A();
}

Eg：
abstract  class Shape {
    abstract public double area();

}
class Triangle extends Shape{
    private double w,h;
    public double area(){
        return w*h/2;
    }
}

class Circle extends Shape{
    private double r;
    public double area(){
        return pi*r*r;
    }
}

③接口

接口：两个系统之间相互联系的约定，相互通讯的标准，仅仅声明抽象函数

public interface K {
    public abstract void  a();
    public abstract void  b();
}

class A implement K,M,N{//相当于继承了接口，但是接口和抽象类不完全一样
//接口的继承是多继承
    public abstract void  a(){}
    public abstract void  b(){}
    public abstract void  c(){}
    public abstract void  d(){}
}

class B {
    void b(){//尽量使用接口类型的变量来访问接口实现的对象
        A a1 = new A();
        K a2 = new A();//通过接口访问对象
        a1.a();
        a2.a();
    }
}

//通常情况下一个类应该全部实现一个接口，也可以部分实现或者不实现

④构造函数

只有一个默认构造函数
函数的名字和类名一样，函数不允许声明任何返回

class A {
    int i;
    A(){
        i = 0;
    }
    A(int j){
        i = j;
    }
}

//不写构造函数，编译器默认添加一个无参构造函数，写了构造函数的编译器不再提供构造函数

class B extends A {
    double d;
    B(double x ){
        super();//构造函数的第一个不是super或者this 自动添加super调用父类的无参构造函数
        d = x
    }
    ------
    B(double x，int m ){
        super(m);
        d = x
    }

}

⑤super和this

函数调用时必须是在构造函数的第一条语句
class A {
    static void b(){}
    void c(){ b(); }

    public static void main(){
        A a1 = new A();
    }
}
this 的引用变量，哪一个对象被调用就指向该对象

class B extends A {
    void c(){
        super.c();
    }
    void d(){
        c();
        super.c();
    }
}

//super 访问父类里面的函数，只可以访问上一级

Eg:

public class Point{
    int x,y;
    public Point(int x,int y){
        this.x = x;
        this.y = y;
    }
    public Point(){
        this(0,0);
    }
    public static void main(){
        Point p1 = new Point(4,6);
        Point p2 = new Point();
    }
}

在一个类的成员变量的位置赋值，赋值语句先于构造函数执行

Java高级编程3-姜国海

猜你喜欢