学自：狂神说
感谢UP主的付出！！

一 面向过程& 面向过程

1.1 面向过程思想

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

1.2 面向对象思想

• 物以类聚，分类的思维模式，思考问题首先解决解决问题需要那些分类，然后对这些分类进行单独思考。最后，才对某个分类下的细节进行面向过程的探索。
• 面向对象适合处理复杂的问题，适合处理需要多人协作的问题。

对于描述复杂的事物，为了从宏观上把握，从整体上合理分析，需要使用面向对象的思路分析整个系统。到微观操作时，仍然需要使用面向过程的思路来处理。

二 面向对象

2.1 什么是面向对象

• 全称：面向对象编程（Object-Oriented Programming ,OOP）
• 面向对象编程的本质：以类的方式组织代码，以对象的方法组织（封装）数据。
• 三大特点：封装、继承、多态
• 从认识的角度考虑：现有对象，后有类【具体到抽象】，以类作为对象的抽象。符合人的认知
• 从代码运行的角度：先有类，后有对象【抽象到具体】，以类作为对象的模版。新颖的认知思路
  倒觉得，有些道生一，一生二，二生三，三生万物的感觉

2.2 关于静态类方法和非静态类方法的区别

2.2.1 调用的不同

• 静态类创建的方法，可以直接调用

       类名.方法名();
1

• 非静态类创建的学生，不可以直接调用

实例化 这个类 new
对象类型 对象名=对象值

类名 对象名= new 对象名();
对象.方法名();
1
2

2.2.2 创建时间的不同

• 静态方法和类一起加载
• 非静态方法 在类实例化之后才存在

2.2.3 感受java的参数传递是值传递

• 值传递

public class Student {
    //静态方法
    public static void say() {
        System.out.println("静态类创建的学生说话了！");
    }
    public void say1() {
        System.out.println("非静态类创建的学生说话了！");
    }
}
1
2
3
4
5
6
7
8
9

public static void main(String[] args) {
        int a=1;
        System.out.println("原来的值我为："+a);

        Application.change(a);
        //分析：如果发生的是引用传递，a的值会变成10
        System.out.println("最终的结果："+a);//结果a=1
    }

    public static void change(int a) {
        a=10;
    }
1
2
3
4
5
6
7
8
9
10
11
12

public static void main(String[] args) {
        Person person1 = new Person();
        System.out.println(person1.name);//null

        Application.chang(person1);

        System.out.println(person1.name);
        //引用传递的本质是值传递
        //类只是一个模板，它的属性没有值，只有创建对象后，对象的属性进行操作
        Person person2=new Person();
        System.out.println(person2.name);
        Application.chang(person2);
        System.out.println(person2.name);
    }

    public static void chang(Person person) {
        //person是具体的一个人，可以改变属性
        person.name="酸梅汤小王子";
    }
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

2. 3 类和对象的关系

• 类是一种抽象的数据类型，它是对某一类事物的整体描述/定义，但是并不代表某一个具体的具体。
  对象是抽象概念的具体实例

2.4 创建与初始化对象

使用new关键字创建对象
使用new关键字创建的时候，除了分配内存空间之外，还会给创建好的对象进行默认的初始化以及对类中构造器的调用。
类中的构造器也称为构造方法，是在进行创建对象的时候必须要调用的。并且构造器有以下两个特点。

• 1. 必须和类的名字相同
• 2. 必须没有返回类型，也不能写void

一个类即使什么都不写，它也会存在一个方法
显示的定义构造器
1. 使用new关键字，本质是调用构造器
2. 用来初始化值
有参构造：一旦定义了有参构造，无参构造就必须显示定义
构造器：
1. 和类名相同
2. 没有返回值

作用：
1.new 本质在调用构造方法
2.初始化对象的值
注意点：
1.定义有参构造之后，如果想使用无参构造，显示的定义一个无参的构造

2.5 小结

1. 属性：字段Field 成员变量
   默认初始化：

• 数字：0 0.0
• char:u0000
• boolean:false
• 引用：null
• 修饰符 属性类型 属性名=属性值！

2. 对象的创建和使用

• 必须使用new 关键字创建对象，构造器 如：Person person =new Person();
• 对象的属性 如：person.name
• 对象的方法 如：person.sleep()

3. 类：
   静态的属性 ——属性
   动态的行为 ——方法

三 大特性

3.1 封装

• 该露的露，该藏的藏
  • 程序设计追去***“高内聚，低耦合”***。
  • 高内聚：类的内部操作细节自动完成，不允许外部干涉。
  • 低耦合：仅尽量的方法给外部使用。
• 封装（数据的隐藏）
  • 通常，应禁止直接访问一个对象数据的实际表示，而应通过操作接口来访问，称为信息隐藏。

终极秘诀：属性私有，get/set

3.1.1 封装的作用

• 1. 提高程序的安全性
• 2. 提高代码的实现细节
• 3. 统一接口
• 4. 系统可维护增加了

3.1.2 案例

String name;//null
    int age;//0

    public String getName() {
        return name;
    }

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

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        if(age>120 || age<0) {
            System.out.println("输入不合理！");
        }
        else {
            this.age = age;
        }
    }
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23

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

        student.setName("酸梅汤小王子");
        System.out.println(student.getName());

        student.setAge(666);
        System.out.println(student.getAge());//默认是0
    }
1
2
3
4
5
6
7
8
9

3.1.3 初识构造器

构造器简介

1. 构造器，也称构造方法、构造函数。作用是构造出来一个类的实例，确保对象得到初始化。
2. 构造器的格式： 权限修饰符 类名(无参/有参){}。
3. 根据有无参数，可分为无参构造 和有参构造。

• 构造器最大的用处就是在创建对象时执行初始化，当创建一个对象时，系统会为这个对象的实例进行默认的初始化。如果想改变这种默认的初始化，就可以通过自定义构造器来实现。
• 构造器可以用***来在初始化对象时初始化数据成员，一个类可以有多个构造器。一个类的构造器的名称必须与该类的名称一致。***要退出构造，可以使用返回语句“return;”
• 构造器：初始化对象，给对象赋值。

构造器的分类：①隐式构造器：系统自带的构造器，它是无参数的，给未赋值的成员变量赋予一个合适的初值。原始类型：0 引用类型：null
注意：书写任意一个显示构造器后，隐式构造器无法手动调用。
②显式构造器：程序员自己书写的构造器，一个类可以书写无数个构造器，new对象时根据实际参数来调用相应构造器，当书写显式构造器后，隐式构造器将无法调用。

• 构造器的作用
  • 创建对象
  • 初始化成员变量

定义方法

• 构造方法的名字必须和所在类的名字一致，没有返回值，但不能声明void。
• 访问权限可以为任意，但是一般情况下使用public方法权限。
• 构造方法中的参数可以根据需要自行定义，参数的不同的构造方法构成重载

//构造方法名必须和该类的类名保持一致，大小写都一样
//构造器没有返回值类型
public 构造方法名(无参数/参数){
    ...
}

1
2
3
4
5
6

构造器重载

重载可以简单理解为：同个方法名，不同的参数列表。

public class X{
    //通过new X()调用
    public X(){
        
    }
    //通过new X("字符串")调用
    public X(String name){
        
    }
}

1
2
3
4
5
6
7
8
9
10
11

构造器的继承

定义父类构造器，由于该构造器自定义了一个带参构造器，覆盖了默认的无参构造器,所以不能直接 new Father() 调用了，除非再定义一个无参构造器。

//父类构造器
public class Father{
    //自定义带参构造器
    public Father(String name){
        System.out.println("父类的带参构造方法!");
    }
    
}

1
2
3
4
5
6
7
8
9

//子类构造器
public class Son extends Father{
    
    //无参构造器
    public Son(){
        /*
        由于Father()没有无参构造器，所以必须在子类型构造器中通过super("字符串")来调用
        如果没定义这句，系统会默认调用super();
        */
        super("");
    }
    
    //带参构造器
    public Son(String name){
        super(name);      
    }  
    
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

快捷键：alt+insert的使用——快速写出构造器

3.2 继承

• 继承的本质是对某一批类的抽象，从而实现对现实世界更好的建模。
• extends的意思是“扩展”。子类是父类的扩展。
• JAVA中类只有单继承，没有多继承！一个儿子只能有一个爸爸，但是一个爸爸可以有多个儿子
  • 继承是类和类之间的一种关系。除此之外，类和类之间的关系还有依赖、组合、聚合等
  • 继承关系的俩个类，一个为子类（派生类），一个为父类（基类）。子类继承父类，使用关键字extends来表示
  • 子类和交类之间，从意义上讲应该具有“is a”的关系

3.2.1 案例

3.2.2 查看类关系的快捷键Ctrl+H

public class Person {
    public void say() {
        System.out.println("人说了一句话");
    }
}
1
2
3
4
5

public class Student extends Person {

}
1
2
3

public class Application {

    public static void main(String[] args) {
        Student student=new Student();
        student.say();
    }

}
1
2
3
4
5
6
7
8

3.3 object类【最大的类】

• Java内置的对象，有很多方法
• 上图就可以看出来

3.4 super

public class Person {
    public void say() {
        System.out.println("人说了一句话");
    }
    String name="爸爸";
}
1
2
3
4
5
6

public class Student extends Person {

    String name="student";

    public void text1()
    {
        System.out.println(name);
        System.out.println(this.name);
        System.out.println(super.name);
    }
}
1
2
3
4
5
6
7
8
9
10
11

public class Application {

    public static void main(String[] args) {
        Student student=new Student();
        student.text1();
    }
}
1
2
3
4
5
6
7

3.5 图形化解说

3.5.1 this的使用

3.5.2 实例化下无参构造的执行

3.6 注意点

• super注意点：
  1.super调用父类的构造方法，必须在构造方法的第一个
  2.super必须只能出现在子类的方法或者构造方法中！
  3.super和this不能同时调用构造方法！
• 代表的对象不同
  this：本身调用者这个对象
  super：代表父类对象的应用
• 前提
  this：没有继承也可以使用
  super：只能在继承条件才可以使用
• 构造方法
  this（）；本类的构造
  super（）：父类的构造！
• 当父类写了有参构造【无参构造同时会没有】，在子类中调用无参构造，会报错，但是调用有参构造成功。

3.3 多态

3.3.0 重写

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

• 1. 方法名必须相同
• 2. 参数列表列表必须相同
• 3. 修饰符：范围可以扩大但不能缩小：public>Protected>Default>private
• 4. 抛出的异常：范围，可以被缩小，但不能扩大：ClassNotFoundException–>Exception（大）
     重写，子类的方法和父类必要一致：方法体不同！
     为什么需要重写？：
     1.父类的功能，子类不一定需要，或者不一定满足！
     
     

3.3.1 多态简介

• 即同一方法可以根据发送对象的不同而采用多种不同的行为方式
• 一个对象的实际类型是确定的，但可以指向对象的引用的类型有很多（父类，有关系的类）
  多态存在的条件：
  • 有继承关系
  • 子类重写父类方法
  • 父类引用指向子类对象
• 注意：多态是方法的多态，属性没有多态性

3.3.2 图形化讲解

一个对象的实际类型是确定的。
可以指向的引用类型就不确定了；父类的引用可以指向子类。
对象能执行那些方法，主要看对象左边的类型，和右边关系不大！
子类没有重写父类的方法，执行父类的方法；子类重写了父类的方法，执行子类的方法。

3.3.3 instanceof详解

• instanceof其实是java的一个二元操作符，和=,<,>这些是类似的，同时它也是被保留的关键字。
• 主要的作用：是为了测试左边的对象，是不是右边的类的实例，返回的是boolean值。

x instanceof y//x是实例，而y则是Class类
1

instanceof，相当于判断当前对象能不能装换成为该类型，java里面上转型是安全的，子类对象可以转换成为父类对象，接口实现类对象可以装换成为接口对象。

🍾🍾好奇一下：如果对象为null，那是什么类型

这个答案是：不知道什么类型，因为null可以转换成为任何类型，所以不属于任何类型，instanceof结果会是false。

• 验证展示
  

🌠🌠补充 ：isInstance()方法

🧩🧩instanceof，isInstance，isAssignableFrom对比

注意：java里面一切皆是对象，所以，class本身也是对象。

3.3.4 多态注意事项

• 多态注意事项
  1.多态是方法的多态，属性没有多态
  2.父类和子类，有联系类型转换异常！CLassCastException！同级别的关系无法转换
  3.存在条件：继承关系，方法需要重写，父类引用指向子类对象！
• Father f1=new Son()；
  1.static方法，属于类，它不属于实例
  2.final常量：
  3.private方法：
  
  
  

1. 父类引用指向子类的对象
2. 把子类转换为父类，向上转型
3. 把父类转换为子类，向下转型：强制转换
4. 方便方法的调用，减少重复的代码！

父类转化为子类，可以正常使用子类的方法。
子类转化为父类，会丢失子类的方法。