Java（类和对象笔记）-计算机考试-空麓网

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

文章目录

一面向过程& 面向过程
- 1.1 面向过程思想
- 1.2 面向对象思想
二面向对象
- 2.1 什么是面向对象
- 2.2 关于静态类方法和非静态类方法的区别
- - 2.2.1 调用的不同
  - 2.2.2 创建时间的不同
  - 2.2.3 感受java的参数传递是值传递
- 2. 3 类和对象的关系
- 2.4 创建与初始化对象
- 2.5 小结
三大特性
- 3.1 封装
- - 3.1.1 封装的作用
  - 3.1.2 案例
  - 3.1.3 初识构造器
  - - 构造器简介
    - 定义方法
    - 构造器重载
    - 构造器的继承
    - ***快捷键：alt+insert的使用——快速写出构造器***
- 3.2 继承
- - 3.2.1 案例
  - 3.2.2 查看类关系的快捷键Ctrl+H
  - 3.3 object类【最大的类】
  - 3.4 super
  - 3.5 图形化解说
  - 3.5.1 this的使用
  - 3.5.2 实例化下无参构造的执行
  - 3.6 注意点
- 3.3 多态
- - 3.3.0 重写
  - 3.3.1 多态简介
  - 3.3.2 图形化讲解
  - 3.3.3 instanceof详解
  - - 好奇一下：如果对象为null，那是什么类型
    - 补充：isInstance()方法
    - 里里instanceof，isInstance，isAssignableFrom对比
  - 3.3.4 多态注意事项

一面向过程& 面向过程 1.1 面向过程思想

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

1.2 面向对象思想

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

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

二面向对象 2.1 什么是面向对象

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

2.2 关于静态类方法和非静态类方法的区别 2.2.1 调用的不同

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

       类名.方法名();

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

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

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

2.2.2 创建时间的不同

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

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

值传递

public class Student {
    //静态方法
    public static void say() {
        System.out.println("静态类创建的学生说话了！");
    }
    public void say1() {
        System.out.println("非静态类创建的学生说话了！");
    }
}

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;
    }

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="酸梅汤小王子";
    }

2. 3 类和对象的关系

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

2.4 创建与初始化对象

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

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

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

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

2.5 小结

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

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

对象的创建和使用

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

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

三大特性 3.1 封装

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

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

3.1.1 封装的作用

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

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;
        }
    }

 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
    }

3.1.3 初识构造器构造器简介

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

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

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

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

定义方法

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

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

构造器重载

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

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

构造器的继承

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

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

//子类构造器
public class Son extends Father{
    
    //无参构造器
    public Son(){
        
        super("");
    }
    
    //带参构造器
    public Son(String name){
        super(name);      
    }  
    
}

快捷键：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("人说了一句话");
    }
}

public class Student extends Person {

}

public class Application {

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

}

3.3 object类【最大的类】

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

3.4 super

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

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

public class Application {

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

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

3.3.1 多态简介

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

3.3.2 图形化讲解

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

3.3.3 instanceof详解

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

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

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

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

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

验证展示

补充：isInstance()方法

里里instanceof，isInstance，isAssignableFrom对比

方法名	详解
instanceof	判断对象和类型之间的关系，是关键字，只能用于对象实例，判断左边的对象是不是右边的类(包括父类)或者接口(包括父类)的实例化。【前面是实例对象，后面是类型】
isInstance	判断对象和类型之间的关系，判断o是不是调用这个方法的class(包括父类)或者接口(包括父类)的实例化。【调用者（前面）是类型对象，参数（后面）是实例对象】
isAssignableFrom	判断的是类和类之间的关系，调用者是否可以由参数中的Class对象转换而来。

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

3.3.4 多态注意事项

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

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

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

Java（类和对象笔记）

Java相关栏目本月热门文章