java面向对象

以类的方式组织代码，以对象的组织（封装）程序。

一个类里面只有方法和属性
一个项目至多只有一个main方法

创建对象

类是抽象的，需要进行实例化

public class Main {
    public static void main(String[] args) {
    //实例化一个对象：类 对象名 = new 构造器
    Student student = new Student();
    }
}

构造器

一般写了有参构造后需添加一个无参构造器

类中的构造器也称为构造方法，是在进行创建对象的时候必须要调用的。并且构造器有以下俩
个特点:

必须和类的名字相同
必须没有返回类型,也不能写void

public class Student {
    String name;
    //无参构造器
    public Student(){
        this.name = "Die Mongsheng";
    }
    //有参构造器,有参构造器在使用new调用对象时要在构造器中添加参数
    public Student(String name){
        this.name = name;
    }
}

public class Main {
    public static void main(String[] args) {
    //有参构造调用
    Student student = new Student("Die Mongsheng");
    }
}

封装

private关键字是封装的关键，被封装的属性不能在main方法中编辑(属性私有)

public class Student {
    private String name;
}

被封装的属性不能直接编辑，但可在类中编写get、set方法编辑

public class Student {
    private String name;

    //get方法来获取属性
    public String getName(){
        return this.name;
    }
    //set方法用来编辑属性
    public void setName(String name){
        this.name = name;
    }

}

public class Main {
    public static void main(String[] args) {
    Student student = new Student();
    student.setName("Die Mengsheng");
    System.out.println(student.getName());
    }
}

继承

java中只有单继承，没有多继承

使一个类获得另一个类的所有属性和方法，使用extends关键字(只有public修饰的属性可以直接继承，private修饰的不行，必须使用get、set)

public class Student extends People {
    
}

super

指向父类的属性，在创建对象时，默认先运行父类的构造器再运行子类的构造器，顺序不能更改

public class People {
    protected String name = "Die Mengsheng";
}

public class Student extends People {
    public void print(){
        System.out.println(super.name);
    }
}

方法的重写

只有非静态方法可以重写
只有public修饰的可以重写

方法名必须相同
参数列表列表必须相同
修饰符:子类可以扩大父类范围但不能缩小父类范围:public>protected>pefault>private
抛出的异常: 子类可以缩小父类范围，但不能扩大父类范围; classNotFoundException(小异常) --> Exception(大异常)

public class People {
    public void print(){
        System.out.println("People");
    }
}

public class Student extends People {
    public void print(){
        System.out.println("Student");
    }
}

public class Main {
    public static void main(String[] args) {
    //方法的调用只和左边定义的数据类型有关
    Student student = new Student();
    student.print();

    //父类的引用指向了子类
    People people = new Student();
    people.print();
    }
}
//结果均为"Student"，因为子类重写了父类的方法

多态

子类能执行那些方法与对象左边的类型指向的引用有关，与右边关系不大

public class People {
    public static void print(){
        System.out.println("People");
    }
}

public class Student extends People {
    public static void print(){
        System.out.println("Student");
    }
}

public class Main {
    public static void main(String[] args) {
    //方法的调用只和左边定义的数据类型有关
    Student student = new Student();
    student.print();

    //父类的引用指向了子类
    People people = new Student();
    people.print();
    }
}
//结果为"Student"，"People",
//因为方法为静态方法，子类能执行那些方法与对象左边的类型指向的引用有关，与右边关系不大

instanceof

判断一个对象是否在某个类中

public class People {
    public static void print(){
        System.out.println("People");
    }
}

public class Student extends People {
    public static void print(){
        System.out.println("Student");
    }
}

public class Main {
    public static void main(String[] args) {
        Student student = new Student();
        //Object -> People -> Student
        System.out.println(student instanceof Student);//ture
        System.out.println(student instanceof People);//ture
        System.out.println(student instanceof Object);//ture
        System.out.println(student instanceof String);//false
    }
}

强制转化(对象)

子转父自动转化，向上转型
父转子强制转化，向下转型

public class People {
    
}

public class Student extends People {
    public void print(){
        System.out.println("Student");
    }
}

public class Main {
    public static void main(String[] args) {
        //子转父自动转化,父类的引用指向了子类
        //子类转父类可能会丢失一些自己本来的方法
        People people = new Student();
       
        people.print()//报错
        //父转子需强制转化
        ((Student)people).print()//输出"Student"
    }
}

抽象类

加入关键字abstract变抽象，抽象类不能new(实例化)

//在类处加入abstract变为抽象类
public abstract class Main {
    //在方法处加入abstract变为抽象方法(抽象方法只能在抽象类中使用)，只有方法名没有具体方法内容
    public abstract void run();
}

子类继承父类时，必须补齐父类的抽象方法的方法体，除非子类也为抽象类

接口

将class替换为interface把类变为接口，接口中的方法默认为 public abstract
接口定义的属性为常量

定义

//将class替换为interface把类变为接口
public interface Main {
    //接口中的方法默认为 public abstract,可不写 public abstract
    void run();
}

接口的实现

通过implements实现接口的实现
实现了接口的类需要重写接口的方法
接口可以多继承
接口不能实现实例化，他没有构造方法

public interface Main {
    void run();
}

public interface People {
     void print()
}

public class Student implements Main,People {
    @Override
    public void run() {
        System.out.println("run");
    }

    @Override
    public void print() {
        System.out.println("people");
    }
}