面向对象知识汇总

1.抽象类与普通类

1. 抽象类就是比普通类多定义了一个抽象方法，出除了不能直接进行对象的实例化操作之外并没有任何的不同
2. 一个抽象类不可以使用final关键字声明，因为final声明的类表示不能被继承，而抽象类又必须辈子类重写。
3. 一个抽象类可以定义构造方法。
4. 抽象方法不要使用private声明：在使用abstract关键字修饰方法时不能使用private修饰，因为抽象方法必须被子类覆写，而如果使用了private声明，则子类是无法覆写的。
5. 在java中允许一个抽象类实现多个接口，而且抽象类实现接口可以不必实现接口中定义的方法。实例如下：

1.1抽象类实现接口

定义接口interface1

public interface interface1 {
    public int print2();
}

定义抽象类abstractclass1实现接口interface1

public abstract class abstractclass1 implements interface1 {
}

2.接口

1. 接口可以被理解为一种特殊的类，是由全局常量和公共的抽象方法所组成。
2. 在接口中抽象方法必须定义为public访问权限，这是绝对不可改变的，即使在接口中不写public，则也是public访问权限。
3. 在很多的java程序中，经常看到写编程接口方法时省略了public，那么就会有很多的读者认为它的访问权限是default，实际上这是错误的，不管写与不写，接口中的方法永远是public的。
4. 接口可以继承(extends)接口，可以实现接口的多继承，比如：public interface interface3 extends interface1, interface2 {}。不过有一个要求，那就是interface1和interface2两个接口中没有冲突的方法定义。所谓冲突的方法定义就是方法名相同，但是返回类型或者参数不同的方法。
5. 接口不可以继承抽象类。
6. java对类只支持单继承，但是一个类可以实现多个接口，这相当于摆脱了单继承的局限。如果被实现的多个接口中有多个相同方法（参数和返回类型都相同），那么在实现接口是相当于同时实现这两个接口的这个方法。如果被实现的接口中有同名但是不同类型的方法，那么这些方法都必须在类中重写实现。

2.1接口的定义

public interface A {
    public static final String name="张三";
    public abstract void print();
    public abstract String getInfo();
}

因为在接口的基本概念中明确声明了接口是由全局常量和公共的抽象方法所组成，因此上述接口可以简写成如下形式：

public interface A {
    String name="张三";
    void print();
    String getInfo();
}

3.对象的多态

在java中多态主要分为两类

1. 方法的重写(override)和方法的重载(overload)
2. 对象的多态

对象的多态又主要分为以下两种类型

1. 向上转型：子类对象->父类对象。用子类实例化父类。父类 父类对象 = 子类实例。程序自动完成
2. 向下转型：父类对象->子类对象。用父类实例化子类。子类 子类对象 = (子类)父类实例。必须明确得指定要转型的子类类型。这里的 (子类) 就是强制类型转换。 在对象向下转型前，必须首先发生对象的向上转型。

多态的实例

父类A

public class A {
    public void fun1()
    {
        System.out.println("A-->public void fun1(){}");
    }

    public void fun2()
    {
        this.fun1();
    }

}

子类B

public class B extends A {
    public void fun1()
    {
        System.out.println("B-->public void fun1(){}");
    }
    
    public void fun3()
    {
        System.out.println("B-->public void fun3(){}");
    }
}

主程序PolyDemo2

public class PolyDemo2 {
    public static void main(String[] args) {
        A a=new B();//向上转型    
        a.fun1();//发生向上转型，调用被子类B重写过的方法
        a.fun2();//fun2没有被子类重写，调用父类A自己的方法，但是fun2又调用自身的fun1，
                 //而fun1被子类B重写过，所以调用子类B中的fun1
        
        B b=(B)a;//向下转型
        b.fun1();//调用自身的方法
        b.fun2();//调用父类A的fun2，但是在父类A中fun2调用fun1，
                 //fun1被子类B重写，所以还是调用子类B中的fun1
        
        b.fun3();//调用自身定义的fun3.
    }

}

程序输出结果：

B-->public void fun1(){}
B-->public void fun1(){}
B-->public void fun1(){}
B-->public void fun1(){}
B-->public void fun3(){}