JZTXT

Java语言学习2

发布时间 2023-06-28 09:58:13作者: wolaile1

JavaSE2

面向对象（OOP）编程

初始面向对象

面向过程 & 面向对象

  • 面向过程思想

    • 步骤清晰简单，第一步做什么，第二步做什么....
    • 面向过程适合处理一些简单的问题

  • 面向对象思想

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

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

什么是面向对象

  • 面向对象编程（Object-Oriented Programming, OOP）
  • 面向对象编程的本质就是：以类的方式组织代码，以对象的组织（封装）数据。
  • 抽象
  • 三大特性：
    • 封装
    • 继承
    • 多态
  • 从认识论的角度考虑是现有对象后又类。对象，是具体的的事物。类是抽象的，是对对象的抽象
  • 从代码运行的角度考虑是先有类后有对象。类的对象是模板。

方法回顾和加深

  • 方法的定义

    • 修饰符
    • 返回值
    • break 和 return的区别
      • break跳出循环
      • return结束方法
    • 方法名
    • 参数列表
    • 异常抛出

  • 方法的调用

    • 静态方法（static关键字修饰）

      • 带static关键字修饰的方法，会在类加载时一起加载。

    • 非静态方法(没有static关键字修饰)

      • 没有static修饰的方法，只有在类实例化之后才存在。

    • 形参和实参

    • 值传递和引用传递

      • 值传递（pass by value）**是指在调用函数时将实际参数复制一份传递到函数中，这样在函数中如果对参数进行修改，将不会影响到实际参数。

        引用传递（pass by reference）是指在调用函数时将实际参数的地址直接传递到函数中，那么在函数中对参数所进行的修改，将影响到实际参数。

      方法的重载

      //引用传递
public class Demo01 {
    public static void main(String[] args) {
        Person person = new Person();
        System.out.println(person.name);

        Demo01.change(person);
        System.out.println(person.name);

    }
    public static void change(Person person){
        person.name = "yuan";
    }
}
class Person{
    String name;
}
//结果 null
//yuan

      //=============
//值传递
public class Demo02 {
    public static void main(String[] args) {
        int a = 1;
        System.out.println(a);

        changeInt(a);
        System.out.println(a);

    }
    public static void changeInt(int a){
        a = 10;
    }
}
//结果 1 1，变量a前后的值没有变

    • this关键字

对象的创建分析

类与对象的关系

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

    • 动物、植物、手机、电脑........
    • Person类、Pet类、Car类，这些类都是用来描述/定义某一类具体的事物应该具备的特点（属性）和行为（方法）

  • 对象是抽象概念的具体实例

    • 小明就是人的一个具体实例，小明家里的旺财就是狗的一个具体实例。
    • 能够体现出特点，展现出功能的是具体的实例，而不是一个抽象的概念。

image-20230110175111547

创建与初始化对象

  • 使用new关键字创建对象

  • 使用new关键字创建的时候，除了分配内存空间之外，还会给 创建好的对象 进行默认初始化 以及对类中的构造器的调用。

  • 类中的构造器也称为构造方法，是在进行创建对象的时候必须要调用的。并且构造器有以下两个特点：

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

  • 构造器必须学会

构造器详解

image-20230111183439905

构造器：

  1. 和类名相同
  2. 没有返回值

作用：

  1. new 本质是在调用构造方法
  2. 初始化对象的值

注意点：

  1. 定义有参构造之后，如果想使用无参构造，显式的定义一个无参构造；当没有有参构造时，无参构造虽然没有显式（让我们看到）的表示出来，但是默认是有的，因为实例化类的时侯，能成功。

创建对象的内存分析：

img

面向对象的三大特性

  • 封装
  • 继承
  • 多态

封装

  • 该露的露，该藏的藏
    • 我们程序设计要求“高内聚，低耦合”。高内聚就是类的内部数据操作细节自己完成，不允许外部干涉；低耦合：仅暴漏少量的方法给外部使用。
    • 封装（数据的隐藏）
      • 通常，应禁止直接访问一个对象中数据的实际表示，而应通过操作接口来访问，这称为信息隐藏。
  • 记住：属性私有，get/set

//当一个类中的属性为私有时，无法直接通过实例化类之后访问，而需要通过调用实例化类中的getter和setter方法来间接的访问或修改属性。

image-20230113153332346
  • 封装的作用
    1. 提高代码的安全性，保护数据
    2. 隐藏代码的实现细节
    3. 统一接口
    4. 系统可维护性提高了

继承

  • 继承的本质是对某一批类的抽象，从而实现对现实世界更好的建模。

  • extends的意思是“扩展”。子类是父类的扩展。

  • JAVA类中只有单继承，没有多继承！（一个子类只能继承一个父类）

  • 继承是类和类之间的一种关系。除此之外，类和类之间的关系还有依赖、组合、聚合等。

  • 继承关系的两个类，一个为子类（派生类），一个为父类（基类）。子类继承父类，使用关键字extends来表示。

  • 子类和父类之间，从意义上讲应该具有“is a”的关系。

IDEA中查看类与类之间的继承关系时，可以使用快捷键“Ctrl + H”

image-20230113154743737
object类
  • 在Java中， 所有的类， 都默认直接或者间接继承object类
super
  > //super属性
  > ![image-20230113161942420](C:\Users\lmyfi\AppData\Roaming\Typora\typora-user-images\image-20230113161942420.png)
  >
  > //super方法
  >
  > ![image-20230113162332624](C:\Users\lmyfi\AppData\Roaming\Typora\typora-user-images\image-20230113162332624.png)

  • super注意点：

    1. 调用父类的构造方法时，super()必须要在子类构造器的第一行

    image-20230113163518724

    image-20230113163552200

    1. super必须只能出现在子类的方法或者构造方法中
    2. super和 this 不能同时调用构造方法！

  • super 与 this 区别：

    1. 代表的对象不同：

      this：本身调用者这个对象

      super：代表父类对象的应用

    2. 前提：

      this: 没有继承也可以使用

      super：只能在继承条件才可以使用

    3. 构造方法：

      this() : 本类的构造

      super() : 父类的构造！

方法重写

//静态的方法
image-20230113165836191

//静态的方法与非静态的方法区别很大！！！，
//下面这一张截图才是真正的重写，重写的方法时非静态的方法。

image-20230113170417671

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

  1. 方法名必须相同
  2. 参数列表必须相同
  3. 修饰符: 范围可以扩大，但不能缩小（比如：父类的方法修饰符为protected,子类重写时可以修改为public的修饰符，但不能修改比protected作用范围更小的修饰符）： public>protected>Default>private
  4. 抛出的异常：范围，可以被缩小，但不能被扩大。 ClassNotFoundExcetion --> Exception(大)

重写，子类的重写的方法必须与父类相同，方法体不同！

方法体：方法体包含具体的语句，定义该方法的功能。

方法为什么需要重写：

  1. 父类的功能，子类不一定需要，或者不一定满足！

​

多态

  • 即同一方法可以根据发送对象的不同而采用多种不同的行为方式。

  • 一个对象的实际类型是确定的，但可以指向对象的引用的类型有很多。

  • 多态存在的条件

    • 有继承关系

    • 子类重写父类方法

    • 父类引用指向子类对象

    • 对象能执行哪些方法，主要看对象左边的类型，和右边的关系不大

    • Student s1 = new Student();
Person s2 = new Student(); //指向子类
Object s3 = new Student();

//Student类继承了Person类，即Person类是Student类的父类
//假设父类中有eat方法，然后在子类重写了这一个方法
s1.eat(); //子类重写父类的方法，执行子类的方法
s2.eat(); //调用的是子类重写后的方法
//当子类Student中有父类Person没有的方法则父类就无法调用，如子类中由run方法
s1.run(); //可以调用
s2.run(); //报错，无法调用，因为父类中没有run的方法

  • 注意：

    1. 多态是方法的多态，属性没有多态性。
    2. 父类和子类，有联系才能互相 转换类型 ！ ClassCastException !
    3. 存在的条件： 继承关系，方法需要重写， 父类引用指向子类对象！Father f1 = new Son();
    4. 不能重写的方法
      1. static 方法，属于类，它不属于实例
      2. final 常量；
      3. private 方法；

  • instanceof. （类型转换） 引用类型

抽象类和接口

抽象类

  • abstract修饰符可以用来修饰方法也可以修饰类，如果修饰方法，那么该方法就是抽象方法；如果修饰类，那么该类就是抽象类。

  • 抽象类型中可以没有抽象方法，但是有抽象方法的类一定要声明为抽象类

  • 抽象类，不能使用new关键字来创建对象，它是用来让子类继承的

  • 抽象方法，只有方法的声明，没有方法的实现，让是用来让子类实现的。

  • 子类继承抽象类，那么就必须要实现抽象类没有实现的抽象方法，否则该子类也要声明为抽象类。

    //抽象类    (java中类没有多继承，但接口可以多继承)
public abstract class Action {


    //抽象方法，只有方法名字，没有方法的实现！
    public abstract void doSomething();

    //1.不能使用new关键字来创建对象，它是用来让子类继承的
    //2.抽象类中可以写普通方法~
    //3.抽象方法必须在抽象类中~
    //抽象的抽象：约束

    public Action() {
    }
}

接口

声明类的关键字是class，声明接口的关键字是interface

  • 普通类：只有具体实现

  • 抽象类：具体实现和规范（抽象方法）都有！

  • 接口：只有规范！ 自己无法写方法~专业的约束！ 约束和实现分离：面向接口编程~

  • 接口就是规范，定义的是一组规则，体现了现实世界中”如果你是...则必须能....“的思想。如果你是天使，则必须能飞。如果你是汽车，则必须能跑。

  • 接口的本质是契约，就像我们人间的法律一样，制定好后大家都遵守。

  • OO的精髓，是对对象的抽象，最能体现这一点的就是接口。为什么我们讨论设计模式都只针对具备了抽象能力的语言（比如：c++、java、c#等），就是因为设计模式所研究的，实际上就是如何合理的去抽象。

接口作用：

  1. 约束
  2. 定义一些方法，让不同的人实现
  3. 接口方法都是：public abstract + 数据类型 + 方法名（）
  4. 接口静态常量都是：public static final + 数据类型 +变量名
  5. 接口不能实例化，接口中没有构造方法
  6. implements可以实现多个多个接口
  7. 必须要重写接口中的方法~

内部类及OOP实战

内部类

  • 内部类就是在一个类的内部再定义一个类，比如，A类中定义一个B类，那么B类相对A类来说就称为内部类，而A类相对B类来说就是外部类了。
  1. 成员内部类
  2. 静态内部类
  3. 局部内部类
  4. 匿名内部类
  5. lambada表达式

异常

异常体系结构

  • Java中把异常当作对象来处理，并定义一个基类java.lang.Throwable作为所有异常的超类。
  • 再Java API中已经定义了许多异常类，这些异常类分为两大类，错误Error和异常Exception.
img

异常处理机制

  • 抛出异常
  • 捕获异常
  • 异常处理五个关键字
    • try、catch、finally、throw、throws

实际应用中的经验总结

  • 处理运行异常时，采用逻辑去合理规避同时辅助try-catch处理
  • 再多重catch块后面。可以加一个catch（Exception）来处理可能被遗忘的异常
  • 对于不确定的代码，也可以加上try-catch，处理潜在的异常
  • 尽量去处理异常，切忌只是简单地调用printStackTrack()去打印输出
  • 尽量添加finally语句块去释放占用的资源

//IDEA快捷键

Ctrl + - 代码折叠

Ctrl + H 代码继承关系查看

Alt + insert 生成器（可以快速产生：构造器，get/set方法）

Alt + Enter 导包，修正代码。

Ctrl + D 复制当前行到下一行

Ctrl + Alt + T 快捷生成if/else或者try/catch

Ctrl + Alt + Shift + s 打开项目结构