【Java面向对象】

面向对象(OOP)：是当前主流的编程思想，注重创建解决问题的对象，将事情分配给各个对象执行。
​

类（class）：是具有相同属性和行为的对象的集合，是对象的模板。
创建类：

public class Test {
    private int num;
    public void fun() {
    }
}

对象（object）：某个类的具体实例，用于执行某类中的方法。
创建对象：

   Test t = new Test();

成员变量：定义在类中，在创建对象时创建，用过对象访问。有默认值。
局部变量：定义在方法中，调用方法时创建。没有默认值，赋值后才能使用。
静态常量：定义在类中，用static和final修饰，类加载时创建，可通过类名访问。需要在定义时赋值。

class Test {
    //静态常量
    final static int ONE = 1;
    //成员变量
    String name;

    void fun() {
        //局部变量,需要赋值才能使用
        int two = 2;
    }
}

构造方法：是一种特殊的方法，方法名和类名一致，没有返回值。

• 每个类在定义后，隐藏有一个默认的无参数的构造方法，写了一个构造方法后，默认隐藏的无参数的构造方法就会失效。
• 创建对象时自动调用对应的构造方法。
• 构造方法通常用于初始化成员变量

创建构造方法：

class Test {
    int num;
    String name;
    
    //无参的构造函数
    public Test() {
    }
    // 有参的构造函数（构造方法的重载）
    public Test(int num, String name) {
        this.num = num;
        this.name = name;
    }
}

使用private关键字对属性进行修饰，可以防止非当前类进行访问，以此达到保护核心代码的目的；再对外提供一组公开的get/set方法用于对该属性的赋值和读取。

class Test {
    private String name;

    public String getName() {
        return name;
    }

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

类B可以通过extends关键字继承类A。

• java中是单继承：一个子类只能有一个父类，一个父类可以有多个子类。
• java中可以多重继承：类B可以继承类A，类C可以继承类B，这时类C可以访问类A和类B中非私有的成员。

class A{
}

class B extends A{
}

方法重写：当子类继承父类后，可以对父类中非私有的方法进行拓展。

class A{
    void fun(){
        System.out.println("父类中的普通方法");
    }
}

class B extends A{
    
    void fun(){
        System.out.println("子类中的普通方法");
    }
}

重载：在一个类中，多个方法的方法名相同，参数列表不同，同名不同参。

class Test {
    void fun() {
    }

    void fun(int a, int b) {
        int result = a + b;
    }

    void fun(int a, String b) {
        String result = a + b;
    }
}

在继承中，子类的对象，可以保存到父类的变量中。在调用方法时，调用的是子类重写后的方法。

class A{
    void fun(){
        System.out.println("父类中的普通方法");
    }
}

class B extends A{
    void fun(){
        System.out.println("子类中的普通方法");
    }
}

class Test{
    public static void main(String[] args){
        A a = new b();
        b.fun() // 子类中的普通方法
    }    
}

this关键字：

• 当对象时，表示当前类的对象。
• 当做构造方法：this() 表示当前类的无参构造方法，只能放在另一个构造方法的第一行。

class Test {
    int num;
    String name;

    public Test() {
        System.out.println("无参构造方法");
    }
   
    public Test(int num, String name) {
        // this() 表示当前类的无参构造方法
        this()；
        // this 当前类的对象
        this.num = num;
        this.name = name;
    }
}

super关键字

• 当对象时，表示当前类的父类对象。
• 当做构造方法：super()表示当前类的父类无参构造方法，只能放在另一个构造方法的第一行。

class A {
    int num;
    String name;

    public A() {
        System.out.println("无参构造方法");
    }
}

class B extends A{
    public B() {
        super();
    }
}

Object类是所有类的根类。任何类都直接或间接的继承了该类，所有类都可以调用或重写Object类中的方法。

• toString()方法：在输出某个对象时自动调用的方法，默认Object中输出的是“对象所在类的全限定名@六进制哈希码”。通常自己定义的类需要重写该方法，用于输出该对象中的属性。

class Test  {
    String name;
    String sex;
    int age;

    @Override
    public String toString() {
        return  name + 't' + sex + 't' + age;
    }
}

• equals()方法：是比较两个对象是否相同的方法。默认Object中使用==比较，所以自定义类后，如果要比较该类的对象，一定要重写equals方法和hashcode方法，根据指定参数比较两个对象是否相同。

class Test  {
    String name;
    String sex;
    int age;

    @Override
    public boolean equals(Object o) {
        if (this == o) return true;
        if (o == null || getClass() != o.getClass()) return false;
        Test test = (Test) o;
        return age == test.age &&
                name.equals(test.name) &&
                sex.equals(test.sex);
    }
}

• 向上转型：子类对象保存到父类的变量中。

    Person p =new Person();
    Object obj=p;

• 向下转型：父类对象强行保存到子类的变量中。

    Object obj=new Object(); 
    Person p=(Person)obj;

final：用于修饰属性、方法和类

• 修饰属性：变量变为常量，不能改变其值。
• 修饰方法：方法不能被重写。
• 修饰类：类不能被继承。

abstract：用于修饰类和方法，表示抽象的。

• 修饰方法时，该方法称为抽象方法，没有方法体。抽象方法只能出现在抽象类中，不能出现在普通类中。
• 抽象类不能创建对象
• 抽象类中有构造方法，但该构造方法不能使用new调用，在创建其子类对象时自动调用
• 抽象类通常需要被继承，继承后子类一定要重写抽象类中的所有抽象方发，除非其子类也为抽象类

interface：用于定义接口的关键字。代替原本的class

• 接口是一个完全抽象类。其中的方法都被 public abstract修饰，其中的属性都被public static final修饰。
• 在jdk1.8后，接口中可以定义默认default方法和静态static方法。
• 接口通常需要一个类去实现，该类使用implements关键字实现接口。实现了接口的实现类，要重写其中所有抽象方法
• 接口没有构造方法，不能实例化对象

public interface USB {
}
public class Mouse implements USB {
}

static：可以修饰方法和属性，表示该方法或属性是静态的，在类加载时保存到内存中，无需对象参数，直接通过类名就能访问。
如果某个属性或方法被高度重用时，可以将其定义为静态的，之后直接通过类名调用。
还可以在类中定义静态代码块static{}。在类加载时自动执行的代码块。