Java OOP

OOP三大特性:继承、封装、多态

Java-类的格式：

    class Student{
        属性声明方法
        private String name;
        //构造方法
        public Student(String name){
            this.name=name;
        }
        //普通方法
        public void study(){
            System.out.println("我去上学了！");
        }
    }

访问修饰符：public，protected，默认，private （表示的范围依次递减）
public: 随意访问；
protected：最极限，不同包的子类可以访问到；
private：只有该类中能访问；
默认：包访问限制，只有该包内能访问；
与C++不同，Java每个单独的方法或者属性都要单独声明他的访问修饰符；

对象声明
Student a=new Student(); //只有这一种方式声明对象；

super和this关键字的使用

super：
用于子类方法中，产生指向父类对象，之后可以通过super来访问父类方法属性；
特别的，在构造方法中注意：
当父类中没有构造函数，写不写super()都可以；
当父类中有构造函数，必须要写一个对应的super()；
因为子类会继承父类，所以用super()构造了一个父类对象后，子类会继承父类的值，所以子类中的属性和父类一致。

this:
指向当前对象的一个引用；
在构造函数中，可以用this（）来调用其他构造函数；

    public Student（）{
        this("zhangsan","Java");
    }
    public Student(String name){
        this(name,"Java");
    }
    #以上两个构造函数都调用了第三个构造函数来实例化
    public Student(String name,String km){
        this.name=name;
        this.km=km;
    }

多态：

继承、方法重载、方法重写、向上转型

方法重载:

public void compare(int a,int b);
public void compare(float a,float b);
方法重载的意义在于操作相同但参数不同时，我们需要重新再写一个函数；
overload（重载）
　　1、参数类型、个数、顺序至少有一个不相同。
　　2、存在于父类和子类、同类中。
3、函数名一样
4、可以有不同的返回类型和访问修饰符；

方法重写：

    class A{
        public int fun1(int a,int b){
            return a+b;
        }
    }
    class B extends A{
        public int fun1(int a,int b){
            return a-b;
        }
    }

override（重写）
　　 1、方法名、参数、返回值相同。
　　 2、子类方法不能缩小父类方法的访问权限。
　　 3、子类方法不能抛出比父类方法更多的异常(但子类方法可以不抛出异常)。
　　 4、存在于父类和子类之间。
　　 5、方法被定义为final和private不能被重写。

向上转型：

    public class A {
        public void fun1() {
            System.out.println("A fun1");
            fun2();
        }
        public void fun2() {
            System.out.println("A fun2");
        }
    }
    #B继承A
    public class B extends A{
        public void fun1(String s) {
            System.out.println("B fun1");
            fun2();
       }
        public void fun2() {
            System.out.println("B fun2");
        }
        public void fun3(){}
    }
    主函数：
    public class Main {
        public static void main(String args[]) {
            A b=new B();
            b.fun1();
            b.fun3();  //编译报错；
        }
    }

调用结果：
A fun1
B fun2

使用向上转型有几个注意点：
编译时会根据声明的类型来寻找属性和方法，如上代码，b的申明类型是A，但它在A中找不到fun3，报错；
但是运行时，调用函数一定是先调用子类的，再调用父类的。
new其实就是在运行时动态分配空间，所以编译时看等号左边，运行时看等号右边。

Java OOP 概括