面向对象（理解！）

ps:学习遇见狂神说的学习笔记

面向过程&面向对象

面向过程思想

1. 步骤清晰简单，第一步做什么，第二步做什么…
2. 面对过程适合处理一些较为简单的问题

面对对象思想

1. 物以类聚，分类的思维模式，思考问题首先会解决问题需要那些分类，然后对这些分类进行单独的思考。最后，才对某个分类下的细节进行面向过程的思索。

（比如说是建房子: 首先需要@1总设计师,再进行细分为@2打地基,粉刷…之后再分为@3…@4…)其中各个部分都为对象,每个@之间就是过程

2. 面向对象适合处理复杂的问题,适合处理需要多人协作的问题!

对于描述复杂的,为了从宏观上把握,从整体上合理分析,我们需要面对对象的思路来分析整个系统。但是，具体到围观操作，仍然需要面向过程的思路去处理。

什么是面向对象

1. 面向对象编程(Object-Oriented Programming,OOP)
2. 面向对象编程的本质就是：以类的方式组织代码,以对象的组织（封装）数据
3. 抽象
4. 三大特征

封装

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

* */
//main方法
public class Application {
    public static void main(String[] args) {
        Student s1 = new Student();

        s1.setName("小罗书记");
        System.out.println(s1.getName());

        s1.setAge(87);
        System.out.println(s1.getAge());

    }
}

//自己定义的方法
//private:私有
public class Student {

    //属性私有
    private String name;//姓名
    private int id;//学号
    private char sex;//性别
    private int age;

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

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

    //set给这个数据设置值
    //alt+insert快速创建set、get
    public void setName(String name){
        this.name = name;
    }

    public int getId() {
        return id;
    }

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

    public char getSex() {
        return sex;
    }

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

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        if (age>0&&age<120) {
            this.age = age;
        }else {
            System.out.println("输入不合法！！");
        }
    }
}

继承

package com.OOP.demo05;
//父类
//在Java中，所有的类都直接或间接的继承object
public class Person {
    //public
    //protected
    //default
    //private
    public int money =10_0000_0000;

    public void say(){
        System.out.println("说了一句话");
    }

    public int getMoney() {
        return money;
    }

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

//主方法
package com.OOP.demo01;

import com.OOP.demo05.Student;

public class Application {
    public static void main(String[] args) {
        Student student = new Student();

        student.say();
        System.out.println(student.money);


    }
}

• java只有单继承，没有多继承(一个儿子只有一个亲生巴巴，而巴巴可以有多个儿子)
• private 私有的东西无法被继承
• ctrl+H可以打开

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-JvyQUu7M-1628500190588)(C:\Users\小罗\Desktop\Typore\专门图片Typora\QQ截图20210305214946.png)]

super

//父类
package com.OOP.demo05;
//在Java中，所有的类都直接或间接的继承object
public class Person {
    protected String name = "小罗书记";

    public Person() {
        System.out.println("Person无参输出");
    }

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

//子类
package com.OOP.demo05;

public class Student extends Person{
    private String name = "qingjiang";

    public Student() {
        //隐藏代码，调用了父类的无参构造
        super();//调用父类的构造器，必须要在子类构造器的第一行
        System.out.println("Student无参输出");
    }

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

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

super注意点：
    1.super调用父类的构造方法，必须在构造方法的第一个
    2。super 必须只能出现在子类的方法或者构造方法中
    3.super和this不能同时调用构造方法！
Vs this:
    代表的对象不同：
        this ：本身调用者这个对象
        super ：代表父类对象的应用
    前提
        this ：没有继承也可以使用
        super：只能在继承条件才能使用
    构造方法
        this()：本类的构造
        super()：父类的构造

方法重写

package com.OOP.demo01;

import com.OOP.demo05.A;
import com.OOP.demo05.B;

public class Application {

    /*静态方法和非静态的方法有很大的区别
    静态方法：方法的调用只和左边定义的有关
    非静态定义：子类重写父类
    重写有时候也可以理解为覆盖
     */


    public static void main(String[] args) {
        B b = new B();
        b.test();

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

package com.OOP.demo05;
//子类
public class B extends A {

    @Override//有功能的注释！
    public void test() {
        super.test();
    }
}

package com.OOP.demo05;
//父类
//重写都是方法的重写，和属性无关
public class A {
    public  void test(){
        System.out.println("A-->test()");
    }
}

重写：需要有继承关系，子类继承父类！

1. 方法名必须相同
2. 参数列表必须相同
3. 修饰符：范围可以扩大但不能缩小：Public>Protected>Default>Private
4. 抛出异常：范围可以缩小但不能扩大 Exception(大）–> ClassNotFoundException(小)

重写：子类方法和父类方法必须一致，方法体不同！

为什么要重写：

• 父类的功能，子类不一定需要，或者不满足
• 快捷键：alt+insert：override（重写）

多态

package com.OOP.demo01;

import com.OOP.Demo06.Person;
import com.OOP.Demo06.Student;

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();

        s1.run();
        s2.run();

        s1.say();
        ((Student)s2).say();

    }
}

//父类
package com.OOP.Demo06;

public class Person {

    public void run(){

    }
}

//子类
package com.OOP.Demo06;

public class Student extends Person {
    @Override
    public void run() {
        System.out.println("son");
    }

    public void say(){
        System.out.println("hehe");
    }
}

多态注意事项

1. 多态是方法的多态，属性没有多态
2. 父类和子类有联系，类型转换异常！ ClassCastException
3. 存在条件：继承关系，方法重写，父类引用指向子类对象！Father a = new son();
4. 无法重写：

• 1. static 方法 属于类，不属于实例
  2. final 常量
  3. private 私有

instanceof

1. instanceof是Java的一个二元操作符，类似于==,>,<等操作符
2. 它的作用是测试它的左边的对象是否是它右边类的具体实例，返回boolean数据类型

---

5. 从认识论角度考虑是先有对象后有类。对象，是具体的事物。类是抽象的，是对对象的抽象（人–>教师）
6. 从代码运行的角度来考虑是先有类后有对象。类是对象的模板(人民币模板–>大量的人民币)

vate 私有

instanceof

1. instanceof是Java的一个二元操作符，类似于==,>,<等操作符
2. 它的作用是测试它的左边的对象是否是它右边类的具体实例，返回boolean数据类型

---

5. 从认识论角度考虑是先有对象后有类。对象，是具体的事物。类是抽象的，是对对象的抽象（人–>教师）
6. 从代码运行的角度来考虑是先有类后有对象。类是对象的模板(人民币模板–>大量的人民币)