8 面向对象

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

---

8.1 方法的回顾

package com.oop.demo01;


// Demo01 类
public class Demo01 {

    // main方法
    public static void main(String[] args) {
        int c = 10;
        int d = 90;
        
        System.out.println(max(c,d));
        sayHello();
    }

    /*
    修饰符 返回值类型   方法名(...){
        // 方法体
        return 放回值；
    }
     */


    // return 结束方法，返回一个结果!
    public static String  sayHello(){
        return "Hello,world";
    }

    public static int max(int a,int b){
        return a>b ? a : b; // 三元运算符；
    }
    
}

           如果没有返回值在方法中的话，结果就会如下这段代码所示：

package com.oop.demo01;

// 值传递
public class Demo04 {
    public static void main(String[] args) {
        int a = 1;
        
        // a 的值始终没有改变过都还是1
        System.out.println(a); // 1

        change(a);

        System.out.println(a); // 1
    }

    // 返回值为空
    public static void change(int a){
        a = 10;
    }
}

---

8.2 类与对象的创建、基础使用

        关于类的创建就是直接在IDEA中的文件下直接创建类，就是点Java的文件，进行编译以后就是点class的文件。创造对象就是：对象类型 对象名 = 对象值。

        我是这样理解的：

        类就可以看做一个做蛋糕的模具，而对象就是按照这个模具所做出来的一个个蛋糕，蛋糕可以外表一样，但是名字可以不一样。比如都是用Student这个类来创建对象。却可以有：

          Student S1 = new Student();

          Student S2 = new Student();

          Student S3 = new Student();........................等等

package com.oop.demo01;

public class Demo02 {
    // 静态方法
    // 非静态方法

    public static void main(String[] args) {
        //实例化这个类
        // 对象类型  对象名 = 对象值
        Student student = new Student();
        student.say();
    }

    // 有static就是和类一起加载的
    public static void a(){
        //c();  -->这里的方法如果调用的话会直接报错。
        /*
            因为被static修饰过的方法是和类一起加载的，
            而他所调用的这个方法没有被static修饰，所以在实例化之后才存在。
         */
    }
    
    // 类实例化之后才存在
    public void c(){
        
    }
}

         可以在类里面再创建一个类，并且在里面的类里调用其他的类，如下面这段代码：

package com.oop.demo01;

// 引用传递：对象，本质还是值传递
public class Demo05 {
    public static void main(String[] args) {

        Perosn perosn = new Perosn();
        System.out.println(perosn.name); // null

       change(perosn); // 调用了方法change
        System.out.println(perosn.name); // 周某
    }

    public static void change(Perosn perosn){
        // perosn是一个类：指向的---> Perosn perosn = new Perosn();这是一个具体的人，可以改变属性
        perosn.name = "周某";
    }
}

//定义了一个Perosn类，有一个属性：name
class Perosn{
    String name; //这里定义了一个name属性，返回值为默认的null
}

---

8.3 构造器

        关于构造器：一个类即使什么都不行都会存在一个方法，这个方法是一个没有参数的方法，

当我们创建对象时所使用的new关键字本质上是在调用我们的构造器。

        需要注意的是：我们可以定义有参数的构造器，如果定义了他，就需要再一次定义本身已经存在的无参构造器。

package com.oop.demo02;

// java ---> class
public class Person {
    // 一个类及时什么都不写它也会存在一个方法
    // 显示的定义构造器

    String name;
    // 实例化初始值
    //1. 使用new关键字，本质是在调用构造器
    //2. 用来初始化值
    // 无参的构造器
    public Person(){
        this.name = "周某";
    }


    // 有参构造：一旦定义了有参构造，无参就必须显示定义
    public Person(String name){
        this.name = name;
    }
}
/*
在可执行的类中的代码：
public class AppLication {

    public static void main(String[] args) {

        //new 实例化了一个对象
        Person person = new Person("周鹭巡");
        System.out.println(person.name); // 周某

    }
}

    构造器：
        1. 和类名相同
        2.没有返回值
    作用：
        1. new 本质在调用构造方法
        2. 初始化对象的值
    注意点：
        定义有参构造之后，如果想使用无参构造，显示定义一个无参的构造
 */

---

8.4 封装

        关于封装就是在类里面定义属性的时候使用修饰符private，在这个类里面可以定义一些可以操作这个属性的方法，这些方法需要特定的名称。

        get元素名 ：获得这个元素的值

        set元素名 ：设置这个元素的值

package com.oop.demo04;

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


    // 提供一些可以操作这个属性的方法！
    // 提供一些public的get、set方法！

    // get 获得这个数据
    public String getName(){
        return this.name;
    }

    // set 给这个数据设置值
    public void setName(String name){
        this.name = name;
    }

    public int getId(){
        return this.id;
    }

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

    public String getSex() {
        return sex;
    }

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

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        if (age < 120 && age > 0){
            this.age = age;
        } else{
            this.age = 20;
        }

    }
}

/*
在可执行类中的代码：
    public static void main(String[] args) {
            Student S1 = new Student();
            S1.setName("周鹭巡");
            S1.setAge(999);
            S1.setId(35);
            S1.setSex("男");

            System.out.println(S1.getSex());
            System.out.println(S1.getId());
            System.out.println(S1.getName());
            System.out.println(S1.getAge());
        }




        封装：
        1.  提高了程序的安全性，保护数据
        2.  隐藏代码的实现细节
        3.  统一接口
        4.  系统可维护增加了
 */

---

8.5 继承、Super

        继承就是直接在类名后面跟上关键词extends与父类的名字，子类可以继承父类的所有方法。

        Super就是在子类中调用父类中的属性或者父类中的方法。

        直接在子类的构造器的代码第一行使用代码super();，就是调用父类的构造器。

        

Person父类：
 

package com.oop.demo05;

// 在Java中，所有的类，都默认直接或者间接继承Object
// Person 人：父类
public class Person /*extends Object*/ {

    public Person() {
        System.out.println("Person无参执行了");
    }

    private int money = 10_0000_0000;
    public void say(){
        System.out.println("说什么呢？");
    }

    public int getMoney() {
        return money;
    }

    public void setMoney(int money) {
        this.money = money;
    }

    protected String name = "zhoumou";

    // 私有的东西无法被继承
    public void print(){
        System.out.println("Person");
    }
}

 Student子类：

package com.oop.demo05;


// 学生 is 人： 派生类，子类
// 子类继承了父类，就会拥有父类的全部方法！
public class Student extends Person {
    // Ctrl + H


    public Student() {
        // 隐藏代码：调用了父类的无参构造
        super();//调用父类的构造器，必须在子类构造器的第一行

        System.out.println("Student无参构造执行了");
    }

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

    public void test1(){
        print();
        this.print();
        super.print();
    }
    private String name = "zlx";
    public void test(String name){
        System.out.println(name);
        System.out.println(this.name);
        System.out.println(super.name);
    }
}

8.6 方法的重写

        我是这么理解的，当创建对象时，类型为这个对象所属的父类时，他所调用的父类引用的方法是指向的子类，就好像儿子不听爸爸话了。

        其实方法的重写就是调用方法是，方法的修饰符静态与非静态的区别。

        你给别人弄成了静态的话，那么调用时遵循的就是创建对象时左边的数据类型了。

        如果是非静态的话，子类就不听父类话了，就都是向子类的方法看齐，你是调用到的父类的方法，但是引用到的确实子类的方法。

可执行类：

public class AppLication{
    public static void main(String[] args) {
         
        //静态的方法与非静态的方法区别很大
        // 方法的调用只和左边的数据类型有关
        A a = new A();
        a.test();


        // 父类的引用指向了子类
        B b = new A();
        b.test();


    }
}

A类：

package com.oop.demo05;

public class A extends B {
    @Override // 注解：有功能的注释！
    public void test() {
        System.out.println("A=>test()");
    }
}

B类：

package com.oop.demo05;

// 重写都是方法的重写与属性无关
public class B {

    public void test(){
        System.out.println("B=>test()");
    }
}

执行后的结果就是：