【Java基础】面向对象、类、属性、方法、封装、构造、重载、继承、重写、this、super

1. 面向对象

万物皆对象
对象的实质就是：属性+方法

1.1 面向对象-类

• 类是具有共同属性和行为的对象的集合
• 类定义了对象的属性和方法
• 通过类可以实例化多个该类的对象，每个对象的属性值不同（类是图纸，对象是按图纸建造出来的很多栋房子）
• 类是Java程序的基本组成单位

1.2 面向对象-定义

• 面向对象的思想不仅是编程思想，现已扩展至设计、测试等各个方面
• 面向对象指的是以对象为基本单位去分析、设计以及实现系统
• Java具备描述对象以及对象之间关系的能力，因此称为面向对象的语言
• 分析过程有对象后又类；开发过程先有类后有对象。

1.3 面向对象-类的结构

• 属性：对象数据的描述
• 方法：对象的行为；
• 构造方法：用于实例化对象
• 内部类：（inner class）即在类体中声明类
• 块：分为静态块，实例块
  其中属性、方法、构造方法经常使用，块和内部类使用较少。

/**
 * @Auther:zyy
 * @Date:2022/8/9
 * @Description:PACKAGE_NAME
 * @Version:1.0
 */
public class Person{
//    属性
    String name;
    int age;
//    构造方法
    public Person(){
        
    }
//    方法
    public void eat(){
        System.out.println("干饭");
    }
    public void speak(){
        System.out.println("talk");
    }
    
//    块
{
    System.out.println("我是实例块");
}
static{
        System.out.println("我是静态块");
}
//    内部类
    class InnerClass{
        
}
}

1.4 面向对象-类的声明

[]是可选项，可有可无

[访问权限修饰符][修饰符] class 类名{
    类体
}

[访问权限修饰符]有两种：public、 default（无需写出）
[修饰符]:final、synchronized、abstract

1.5 面向对象-类的作用

类就是一个模板，定义多个对象共同的属性和方法
根据上面的Person类就可以创建多个人对象，如张三、李四。

1.6 面向对象-属性

属性的定义：
属性即对象的数据
注：属性又称为成员变量，是声明类的变量，在方法体中声明的变量称为局部变量或临时变量。
属性的声明：

[访问权限修饰符][修饰符] 数据类型 属性名[=初值]；
private String name;
private double salary;
private static int count=0;

1.7 面向对象-方法

1.7.1声明

【】中的内容是可选项，可有可无

[访问权限修饰符][]修饰符 返回值数据类型 方法名(形式参数列表){
    执行语句;
    return 返回值;
}

1.7.2 解释

？	解释
什么是方法？	方法就是定义在类中具有特定功能的一段独立的小程序；方法也称为函数。
访问权限修饰符及修饰符	访问权限控制方法被调用的范围；修饰符包括：static/final/abstract/synchronized
返回值类型	方法运行后的返回结果的数据类型，如果没有返回值使用void。
参数类型	形式参数的数据类型
形式参数	就是一个变量，用于存储调用方法时传递给方法的实际参数
return	用于结束方法
返回值	该方法执行后的结果，该结果会返回给调用者。

1.7.3 特点

• 特殊情况
  没有返回值类型用void关键字表示
  return的后面直接用;结束,return可以省略不写
• 特点
  。定义方法可以将功能代码进行封装。
  。便于该功能进行复用
  。方法只有被调用才会被执行
  。方法的出现提高代码复用性
  。方法若没有返回值，则用关键字void表示，那么该方法中的return语句如果在最后一行可以省略不写；
  。方法中可以调用方法，不可以在方法内部定义方法。
  。定义方法时，方法的结果应返回给调用者，交由调用者处理
  定义时注意：①是否有返回值及类型②需要的参数类型③方法的功能。

2.封装（面向对象的特性）

任何事物都有它的功能(行为)，而提供这些功能就必须有一些必要的物质基础(属性)。比如，运动员能够进行比赛(功能)，是由他的身体素质(属性)决定的。因此，封装性的第一种体现就是:功能和属性的集合性。
另一方面，我们常说的“知人知面不知心”，所反映的就是面向对象中“封装”的另一种表现:把不想被人知道的属性或方法隐藏到内部，外部不能获知(不可访问)这些属性和方法。只把想让别人(外部)知道的东西进行公开。

2.1例子

public class Dog {
    public void play(){
        System.out.println("玩");
    }
    public void run(){
        System.out.println("跑");
    }
    public void sleep(){
        System.out.println("睡");
    }
    public void eat(){
        System.out.println("吃");
    }
}

public class Main {
    public static void main(String[] args) {
        Dog dog1 = new Dog();
        dog1.eat();
    }
}

3.构造方法

3.1 作用

想要使用Java类，必须创建类的对象，即对类进行实例化。而创建对象就必须使用构造方法。因此，构造方法几乎是一个类必须有的元素。
构造方法的作用，对类进行实例化，即创建对象

3.2 形式

[访问权限修饰符]类名(形式参数){方法体}

// 举例
public class Car{
    private String color;
    private double price;
    public Car(){
    }
    public Car(String c){
        color = col;
    }
    public Car(String c,double p){
        color = c;
        price = p;
    }
}

3.3 与普通方法区别

• 构造方法
  实例化对象时调用
  没有返回值，连void都没有
  方法名必须与类名相同
  不能使用修饰符，包括static、final、abstract
• 方法
  分静态方法和非静态方法
  可以使用修饰符，包括static、final、abstract
  静态方法可用类名直接调用，非静态方法要用对象调用
  返回值可有可无，如果没有声明时要加void
  方法名最好不跟类名一样。

3.4 默认构造方法

为什么创建了类后，不写构造方法，依然可以使用new进行实例化呢?
任何一个Java类都默认有一个无参构造方法。也就是说，即使类中没有声明无参的构造方法，照样可以直接使用没有参数的构造方法。
然而，只要在一个Java类中定义了一个构造方法后，默认
的无参构造方法即失效。

3.5 例子

/**
 * @Auther:zyy
 * @Date:2022/8/18
 * @Description:PACKAGE_NAME
 * @Version:1.0
 */
public class Compare {
    private int a;
    private int b;
    private int c;
    public Compare(){
    }
    public Compare(int a,int b,int c){
        this.a = a;
        this.b =b;
        this.c = c;
    }
    public void max(){
        System.out.println("三个数中最大值："+Math.max(Math.max(a,b),c));
    }
    public void min(){
        System.out.println("三个数中最小值："+Math.min(Math.min(a,b),c));
    }
}

import java.util.Random;

public class Main {
    public static void main(String[] args) {
//        Dog dog1 = new Dog();
//        dog1.eat();
//        MyMath m1 = new MyMath(3,4);
//        System.out.println(m1.toSum());
        Compare c1 = new Compare(3,4,5);
        c1.max();

    }
}

4. 方法重载

4.1 定义

在java中如果有多个同名但是不同参数的方法就称为“方法的重载”
编译器会根据调用时传递的实际参数自动判断具体调用的哪个重载方法，如：

// add方法的重载
int add(int x, int c){......}
float add(float x, int c){...}
double add(double x, double x){....}
long add(int x, int x, int x){...}

4.2 三大原则

• 方法名相同
• 参数不同
  数量不同 类型不同 顺序不同
• 同一作用域（同一个类内部）
  方法重载跟方法的返回值类型没有任何关系。也就是说，只有返回值不同的方法不构成重载。
  注意功能也要类似哦

4.3 作用域

只有属于同一作用域范围内的方法才能构成重载，以下两个在两个不同的类，不构成重载

class First{
...
   public void show(){
   ...
   }
...
}

class Second{
...
    public void show(int x){
    .....
    }
....
}

4.4 例子

/**
 * @Auther:zyy
 * @Date:2022/8/18
 * @Description:PACKAGE_NAME
 * @Version:1.0
 */
public class MyMath{
    private int a;
    private int b;
    private int c;
    public MyMath(){

    }
    public MyMath(int a,int b){
        this.a = a;
        this.b = b;
    }
    public int toSum(int a,int b){
        int sum = 0;
        sum = a+b;
        return sum;
    }
    public int toSum(int a,int b,int c){
        int sum = 0;
        sum = a+b+c;
        return sum;
    }
    public double toSum(double a, double b){
        double sum1 = 0;
        sum1 = a+b;
        return sum1;
    }
}

import java.util.Random;

public class Main {
    public static void main(String[] args) {
//        Dog dog1 = new Dog();
//        dog1.eat();
        MyMath m1 = new MyMath(3,4);
        System.out.println(m1.toSum(40,50));
        System.out.println(m1.toSum(150.5,150.5));
        System.out.println(m1.toSum(1,1,1));
//        Compare c1 = new Compare(3,4,5);
//        c1.max();
    }
}

5. 继承

5.1 定义

继承机制是面向对象程序设计不可缺少的关键概念，是实现软件可重用的根基，是提高软件系统的可扩展性与可维护性的重要机制
所谓继承是指一个类的定义可以基于另一个已经存在的类，即子类基于父类，从而实现父类代码的重用，子类能吸收已有类的数据属性和行为，并能扩展新的能力。

5.2 形式

【访问权限修饰符】【修饰符】 子类名 extends 父类名{子类体}

public class Shape{
    public void draw(){}
}
public class Circle extends Shape{
    public double getDiameter(){
       return 0.0;
    }
}

5.3 作用-代码复用

子类对象可以直接调用父类的属性和方法
上面5.2中的代码：子类对象可以直接调用父类的方法，强调复用性

Circle circle = new Circle();
circle.draw();

6. 方法重写(覆写)

6.1 定义

子类可以重写父类中的某一种方法，称为方法覆写，也称方法重写，是继承中非常重要的知识点。如果子类需要修改从父类继承到的方法的方法体，就可以使用方法复写。

6.2 原则

同名
同参
同返回值
访问权限不能缩小

7.this关键字

7.1 用途

this关键字代表自身，在程序中主要的用途

• 使用this关键字在自身构造方法内部引用其他构造方法、
• 使用this关键字代表自身类的对象
  直接使用this
  使用this关键字引用成员变量
  使用this关键字引用成员方法。
  注意：this关键字必须放在非静态方法里

7.2 this引用成员变量

在一个类的方法或构造方法内部，可以使用“this.成员变量名”这样的格式来引用成员变量名，常常用来区分同名的成员变量和局部变量。

public class ReferenceVariable{
    private int a;
    public ReferenceVariable(int a){
        this.a=a  
    }
    public int getA(){
        return a;
    }
    public void setA(int a){
        this.a = a;
    }
}

7.3 this引用构造方法

在一个类的构造方法内部，也可以使用this关键字引用其它的构造方法，这样可以降低代码的重复，也可以使所有的构造
方法保持统一,这样方便以后的代码修改和维护，也方便代码的阅读。

public class ReferenceConstructor{
    int a;
    public ReferenceConstructor(){
        this(0);
    }
    public ReferenceConstructor(int a){
        this.a=a;
    }
}

7.4 this引用成员方法

在一个类的内部，成员方法之间的互相调用时也可以使
用“this. 方法名(参数)”来进行引用。

public class ReferenceObject{
    ReferenceObject instance;
    public void hello(){
        syso("helloWorld");
    }
    public void sayHello(){
        this.hello();
    }
}

7.5 this代表自身对象

在一个类的内部，也可以使用this代表自身类的对象，或者换句话说，每个类内部都有一个隐含的成员变量，该成员变量的类型是该类的类型，该成员变量的名称是this

public class ReferenceObject{
    ReferenceObject instance;
    public ReferenceObject(){
        instance = this;
    }
    public void test(){
        syso(this);
    }
}

8. super关键字

8.1 用途

super关键字代表父类引用，是主要应用

• 在子类构造方法中要调用父类的构造方法，需要注意：super语句只能出现在子类构造方法的第一行。
• 当子类方法体中的局部变量或者子类的成员变量与父类成员变量同名时，即子类局部变量覆盖父类成员变量时，用“super.成员变量名”来引用父类成员变量。
• 当子类的成员方法覆盖了父类的成员方法时，也就是子类和父类有完全相同的方法定义（方法体可以不同），此时，用“super.方法名（参数列表）”的方式访问父类的方法。
• 与this的区别，this通常指代当前对象，super通常指代父类。

8.2 子类构造方法中要调用父类构造方法

在子类构造方法中要调用父类的构造方法，需要注意：super语句只能出现在子类构造方法第一行。

class Base{
    Base{
        syso("Base");
    }
}
public class Checket extends Base{
    Checket(){
        super();
        syso("Checket");
    }
    public static void main(String args[]){
        Checket c = new Checket();
    }
}

8.3 调用父类成员变量或方法

子类中的成员变量或方法与父类中的成员变量或方法同名，因为子类中的成员变量或方法名优先级高，所以子类中的同名成员变量或方法就隐藏了父类的成员变量或方法，但是我们如果想要使用父类中的这个成员变量或方法，就要使用super。

class Country{
    String name;
    void value(){
        name = "china";    
    }
}

class City extenda Country{
    String name;
    void value(){
        name = "Xi`an";
        super.value();//不调用此方法时，super.name返回的是父类的成员变量的值null
        syso(name);
        syso(super.name);
    }
    public static void main(String[] args){
        City c = new City();
        c.value();
    }
}

9.this和super

this通常指代当前对象，
super通常指代父类对象

class Person{
    public static void prt(String s){
        System.out.println(s);
    }
    Person(){
        prt("A Person.");
    }
    Person(String name){
        prt("A person name is "+ name);
    }
}

import jdk.internal.dynalink.beans.StaticClass;

/**
 * @Auther:zyy
 * @Date:2022/8/18
 * @Description:PACKAGE_NAME
 * @Version:1.0
 */
public class Chinese extends Person {
    Chinese(){
        super();//调用父类无形参构造方法(1)
        prt("A chinese");//(4)
    }
    Chinese(String name){
        super(name);//调用父类具有相同形参的构造方法（2）
    }
    Chinese(String name, int age){
        this(name);//调用当前具有相同形参的构造方法
        prt("his age is "+age);
    }
    public static void main(String[] args){
        Chinese cn = new Chinese();
        cn = new Chinese("小明");
        cn = new Chinese("小马",22);
    }
}
//结果
//A Person.
//A chinese
//A person name is 小明
//A person name is 小马
//his age is 22