面向对象 、构造器、封装 、继承 、super && this关键字、方法重写、多态 、instanceof、static 关键字、抽象类 abstract 、接口

Java基础学习巩固-5，看目录食用~
Java是面向对象的语言

【1】 面向对象

面向对象编程的本质：以类的方式组织代码，以对象的组织（封装）数据。

三大特性：封装、继承、多态

对象是具体的事物；类是抽象的，是对对象的抽象。

类是对象的模板。

【2】构造器

构造器：
1、和类名相同
2、没有返回值

作用
1、new本质在调用构造方法
2、初始化对象的值

注意
定义有参构造之后，如果想使用无参构造，显示的定义一个无参的构造。

// 学生类
public class Student {
    // 属性： 字段
    String name;
    int age;
    
    public Student() {
    }

    public Student(String name, int age) {
        this.name = name;
        this.age = age;
    }
}

public class Demo1 {
    public static void main(String[] args) {
        Student xiaoming = new Student();
        Student xiaohong = new Student("小红",20);

        System.out.println(xiaoming.name+xiaoming.age);  // null0
        System.out.println(xiaohong.name+xiaohong.age);  // 小红20
    }
}

【3】封装

封装（数据的隐藏）
通常，应禁止直接访问一个对象中数据的实际表示，而应通过操作接口来访问，这也称为信息隐藏。

属性私有，get/set

public class Student {
    // 属性私有
    private String name;
    private int id;
    private char sex;

    // 提供一些操作接口来访问

    public String getName() {
        return name;
    }

    public int getId() {
        return id;
    }

    public char getSex() {
        return sex;
    }

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

    public void setId(int id) {
        this.id = id;
    }

    public void setSex(char sex) {
        this.sex = sex;
    }
}

作用：
1、提高程序的安全性，保护数据
2、隐藏代码的实现细节
3、统一接口
4、系统可维护增加

【4】继承

• extends是“扩展”，子类是父类的扩展

• Java中类只有单继承，没有多继承

• 子类继承父类，可用于父类的全部方法。

• Java中，所有的类都默认直接或间接基础Object

  public class Person /* extends Object*/{
   }
  

【5】 super && this

super

• super调用父类的构造方法，必须在构造方法的第一个
• super必须只能出现在子类的方法或者构造方法中
• super和this不能同时调用构造方法

this

• 代表对象不同
  • this ：本身调用者这个对象
  • super：代表父类对象的应用
• 前提
  • this：没有继承也可以使用
  • super：只能在继承条件下使用
• 构造方法
  • this()：本类的构造
  • super()：父类的构造

【6】方法重写

@override

静态方法是类的方法，而非静态是对象的方法

有static时，b调用了B类的方法，因为b是用B类定义的：【向上转型】

没有static时，b调用的是对象的方法，而b是用A类new出来的对象，因此调用A的方法：

重写：需要有继承关系，子类重写父类的方法

• 方法名相同
• 参数列表相同
• 修饰符范围可以扩大 public > protected > default >private
• 抛出的异常：范围可以缩小，不能扩大

为什么需要重写：

• 父类的功能，子类不一定需要，或者不一定满足

【7】多态

多态编译：同一个方法可以根据发送对象的不同而采取多种不同的行为方式

多态存在的条件：

• 有继承关系
• 子类重写父类方法
• 父类引用执行子类对象

public class Application {
    public static void main(String[] args) {
        // 一个对象的实际类型是确定的
        new Student();
        new Person();

        // 指向的引用类型是不确定的：父类的引用指向子类

        // Student能调用的方法都是自己的或者继承父类的
        Student s1 = new Student();
        // Person父类型，可以指向子类，但不能调用子类独有的方法
        Person s2 = new Student();
        Object s3 = new Student();

        // 对象能执行哪些方法，主要看对象左边的类型
        s2.eat();
        s1.eat();

        s1.run();
        ((Student) s2).run();
    }
}

【8】instanceof

public class Application {
    public static void main(String[] args) {
        // Object > String
        // Object > Person > Teacher
        // Object > Person > Student
        Object obj = new Student();

        System.out.println(obj instanceof Student);  // true
        System.out.println(obj instanceof Person);   // true
        System.out.println(obj instanceof Object);   // true
        System.out.println(obj instanceof Teacher);  // false
        System.out.println(obj instanceof String);   // false
}

【8】static 关键字

1.静态变量

public class Person {
    private static int age; // 静态变量
    private double score; // 非静态变量
      
    public static void main(String[] args) {
        Person p = new Person();
        // 使用类名访问
        System.out.println(Person.age);
//        System.out.println(Person.score);  // 非静态变量不能使用
    }

2.静态方法

public class Person {
    // 静态方法
    public void run(){
    }

    public static void go(){
    }

    public static void main(String[] args) {
        // 使用类名访问
        Person.go();
        // 使用对象访问
        new Person().run();
    }

3.静态代码块

public class Person {
    // 2:赋初值
    {
        System.out.println("匿名代码块");
    }

    // 1:只执行一次
    static {
        System.out.println("静态代码块");
    }

    // 3
    public Person(){
        System.out.println("构造方法");
    }

    public static void main(String[] args) {
        Person p1 = new Person();
        System.out.println("=================");
        Person p2 = new Person();
    }
}

// 输出
静态代码块
匿名代码块
构造方法
=================
匿名代码块
构造方法

4.静态导入包

import static java.lang.Math.random;
import static java.lang.Math.PI;

public class Test{
	public static void main(String[] args){
		// System.out.println(Math.random());
		System.out.println(random());
		System.out.println(PI);
	}
}

【9】抽象类 abstract

abstract 修饰类 、修饰方法

1、抽象类中可以没有抽象方法，但抽象方法的类一定要声明为抽象类

2、抽象类：不能使用new关键字类创建对象，它是用来让子类继承的

3、抽象方法：只有方法的声明，没有方法的实现，它是用来让子类实现的

// 抽象类  extends单继承
public abstract class Action{
	public abstract void run();
}

【10】接口 interface

接口的本质是契约，接口可以多继承

作用：
1、约束
2、定义一些方法，让不同的人实现
3、方法都是public abstract，常量都是public static final
4、接口不能被实例化，接口中没有构造方法
5、implements可以实现多个接口
6、必须要重写接口中的方法

⭐理解
普通类：只有具体实现
抽象类：具体实现和规范(抽象方法)都有
接口：只有规范--------约束和实现分离：面向接口编程~