Java面向对象的理解

Java是一门面向对象的语言，因此它的基本结构是class。

一、首先谈谈类中的方法和属性

 在一个类中可以有多种属性和方法，他们大致可以分为公开的public和私有的private，顾名思义公开的是可以公开访问的，而私有的则只能自己访问自己，代码的写法为:

class Person {
    public String name;
    private int age;
}

上述代码中Person类中含有name和age两种属性，但name是可以被公共访问的而age则不行。

同样，方法也可以用public和private修饰

注意：一般为了防止一个类中的属性值被随意修改，所以一般在一个类中的属性值都是私有的，而可以通过公开的方法对其进行设置和访问。

例如：

public class Main {
    public static void main(String[] args) {
        Person ming = new Person();
        ming.setName("lipu"); // 调用创建对象中的设置name方法
        ming.setAge(18); // 调用创建对象中的设置age方法
        System.out.println(ming.getName() + ", " + ming.getAge());
    }
}

class Person {
    private String name;
    private int age;

    public String getName() {
        return this.name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getAge() {
        return this.age;
    }
}

总结来说：类中可以包含各种包含修饰符的属性和方法用于对一个类的创建。

二、对构造方法的理解

创建完类后，在new一个实例对象的时候都要初始化对象，构造方法的主要作用就是对对象进行初始化，构造方法简单的理解就是一个和类名一样的一个方法，好处就是在创建实例的时候会同时被调用，当对象被创建后，同时该方法也被调用完成，一般用于初始化对象:

例如：

public class Main {
    public static void main(String[] args) {
        Person p = new Person("lipu", 18);//创建对象的时候会调用构造方法完成了初始化
        System.out.println(p.getName());
        System.out.println(p.getAge());
    }
}
class Person {
    private String name;
    private int age;

    public Person(String name, int age) { //该方法就是构造方法
        this.name = name;
        this.age = age;
    }
    
    public String getName() {
        return this.name;
    }

    public int getAge() {
        return this.age;
    }
}

在创建Person类的实例的时候就会直接调用Person类中的Person方法，从而实现了对实例对象的初始化。构造函数的参数形式和类型就在class的内部。我们也可以理解为构造函数其实就是一种特殊的方法。

结合方法的重载可根据参数的不同，在一个class类中设置多种构造函数，例如：

class Person {
    private String name;
    private int age;

    public Person(String name, int age) {// 有参构造方法，参数为String name,int age
        this.name = name;
        this.age = age;
    }

    public Person(String name) {// 有参构造方法，参数为String name
        this.name = name;
        this.age = 12;
    }

    public Person() {// 无参构造方法
    }
}

上述class中的构造方法就借助了重载，这样创建实例的时候会根据参数的不同自动进行不同的构造方法选择。

三、方法的重载

方法的重载可简单理解为同一种方法，但使用了不同的形参，调用方法的时候会根据形参的不同进行自动的选择，例如：

class Hello {
    public void hello() {
        System.out.println("Hello, world!");
    }

    public void hello(String name) {
        System.out.println("Hello, " + name + "!");
    }

    public void hello(String name, int age) {
        if (age < 18) {
            System.out.println("Hi, " + name + "!");
        } else {
            System.out.println("Hello, " + name + "!");
        }
    }
}

同样的hello方法，但是对于不同的参数会进行自动的选择。

注意！重载中方法的内容也是可以不同的，所以可以根据形参用来做不同的接口使用。

四、继承

继承顾名思义就是子类继承父类的财产（方法和属性）

例如，我们定义了一个Person类如下：

class Person {
    private String name;
    private int age;

    public String getName() {...}
    public void setName(String name) {...}
    public int getAge() {...}
    public void setAge(int age) {...}
}

Student作为Person自然要继承Person中的属性和方法，但同时它又有一些新的特性，为了不麻烦的在创建Student时又再一次的添加Person中的内容，所以采用继承的方法，使用关键字extends，将Person中存在的方法与属性传给Student：

class Student extends Person {
    // 不要重复name和age字段/方法,
    // 只需要定义新增score字段/方法:
    private int score;

    public int getScore() { … }
    public void setScore(int score) { … }
}

这样创建的类Student就包含了Person中的方法和属性，此处我们称Person为父类，Student为子类。

注意继承无法访问父类中的private方法和属性，例如：

 解决此方法只需将父类中的修饰符private改为protected就可以了。

在调用子类的构造方法时，会出现子类无法调用父类构造方法的情况，此时就要用到super(超类)

五、多态

在上述的继承中存在这一个有趣的问题，当父类中的方法与子类中的方法完全相同的时候就会出现重写（Override）

此时就出现了一个问题子类究竟使用了谁的方法。

注意：重写（Override）是指父类与子类中的方法名称，参数，返回值完全相同，唯一不同的只有方法中的内容。

如下例子所示：

public class OverRide {
    public static void main(String[] args) {
        People pp=new People();
        pp.run();//打印People run
    }
}

class Devil {
    public void run() {
        System.out.println("Devil run");
    }
}

class People extends Devil {
    @Override 
    public void run() {
        System.out.println("People run");
    }
}

由上述的例子可知，究竟调用的是子类还是父类的方法只有在运行中时才知道。

此处就引入了多态的概念：针对某个类型的方法调用，其真正执行的方法取决于运行时期实际类型的方法。

简单可以理解为一种方法的多种状态。

上述代码中的@Override是重写的注解，作用为告诉我们下面的内容为重写同时也告诉电脑下面的内容为重写，因此当重写的代码写错是也会给出相应的警告。

注解的作用就向人类和电脑同时解释。

注意！重载和多态的区别，多态是在重写的基础上进行的，重写要求方法名相同，方法参数相同，返回值也相同。重载只是方法名相同，参数不同。

final是什么鬼东西：

继承可以允许子类覆写父类的方法。如果一个父类不允许子类对它的某个方法进行覆写，可以把该方法标记为final。用final修饰的方法不能被复写。

如果一个类不希望任何其他的类继承自它，那么可以把这个类的本身标记为final。用final修饰的类不能被继承。