Java——封装、继承、多态和异常机制

最新推荐文章于 2025-02-12 21:17:22 发布

J寒

最新推荐文章于 2025-02-12 21:17:22 发布

阅读量257

点赞数

分类专栏： JavaSE笔记文章标签： java

本文链接：https://blog.youkuaiyun.com/chu_dianxia/article/details/115210176

版权

JavaSE笔记专栏收录该内容

5 篇文章

订阅专栏

JavaSE（4）

面向对象编程（2）

1.封装详解

该露的露，该藏的藏
数据的隐藏
我们程序设计要追求“高内聚，低耦合”。高内聚就是类的内部数据操作细节自己完成，不允许外部干涉；低耦合：仅暴露少量的方法给外部使用

记住这句话就够了：属性私有（get/set）

private:私有针对于属性

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

public class Teacher {
    private String name;

    public String getName() {
        return name;
    }

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

alt+insert 快捷键
意义：
1. 提高程序的安全性，保护数据
2. 隐藏代码的实现细节
3. 统一接口
4. 系统可维护增加了

2.继承详解

继承
1. 继承的本质是对某一批类的抽象，从而实现对现实世界恒昊的建模
2. extends的意思是“扩展”，子类是父类的扩展
3. Java中类只有单继承，没有多继承。（一个儿子只能有一个（亲生）爸爸，但是一个爸爸可以有多个儿子）
4. 继承是类和类之间的一种关系。除此，还有依赖、组合、聚合等
5. 继承关系的两个类，一个为子类（派生类），一个为父类（基类）。子类继承父类，使用关键字extends来表示。
6. 子类和父类之间，从意义上讲应该具有“is a"的关系
  - 子类继承了父类，就会拥有父类的全部方法！私有的无法继承
7. Object
  - ctrl+H 快捷键，查看类之间的继承
  - 在Java中所有的类都默认直接或间接间接继承Object
8. super
9. 方法重写（重点）——多态

super详解

//父类：
public class Person {
    protected String name="张三";
}

//子类：
public class Student extends Person{
    private String name="李四";

    public void test(String name){
        System.out.println(name);//王五
        System.out.println(this.name);//李四
        System.out.println(super.name);//张三
    }
}

//主体程序：
public class Text {
    public static void main(String[] args) {
        Student student=new Student();
        student.test("王五");
    }
}

私有的东西无法被继承！
super()；//调用父类的东西。调用父类的构造器，必须要在子类构造器的第一行

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

3.方法重写

重写都是方法的重写，和属性无关
父类的引用指向子类

Override 重写

例子：

//子类：
public class Pet {
    public void shout(){
        System.out.println("宠物叫了一声");
    }
}

//父类：
public class Dog extends Pet{
    @Override
    public void shout() {
        System.out.println("狗叫了一声");
    }
}

//主体：
public class Text {
    public static void main(String[] args) {
        Pet pet=new Pet();
        Dog dog=new Dog();
        pet.shout();
        dog.shout();
    }
}

alt+insert快捷键
静态的方法和非静态的方法区别很大！
- 静态方法：方法的调用只和左边定义的数据类型有关
- 非静态方法：重写
重写：子类的方法和父类必须一致，方法体不同。
重写的总结：
- 需要有继承关系，子类重写父类的方法
  1. 方法名必须相同
  2. 参数列表必须相同
  3. 修饰符：范围可以扩大但不能缩小。Public>Protected>Default>Private
  4. 抛出的异常：范围可以被缩小，但不能扩大

思考：为什么需要重写？

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

4.多态

什么是多态？
1. 即同一个方法可以根据发送对象的不同采用多种不同的行为方式
2. 一个对象的实际类型是确定的，但可以指向对象的引用类型有很多（父类有关系的类）
3. 多态存在的条件：
  1. 有继承关系
  2. 子类重写父类
  3. 父类引用指向子类对象
  4. 注意：多态是方法的多态，属性没有多态性
  5. instanceOf（类型转换）引用类型
- 动态编译：类型：可扩展性
- 一个对象的实际类型是确定的，可以指向的引用类型就不确定了，父类的引用指向子类
```
Student student1=new Student();
Person  student2=new Student();
Object  student3=new Student();
```
- 子类重写了父类的方法，执行子类的方法
- 对象能执行哪些方法，主要看对象左边的类型，和右边关系不大
多态注意事项
1. 多态是方法的多态，属性没有多态
2. 父类和子类有关系。类型转换异常!ClassCastException!
3. 存在条件：继承关系，方法需要重写，父类引用指向子类对象
```
Father f1=new Son();
```
4. 无法重写，没有多态
  - static 方法，属于类，它不属于实例
  - final 常量
  - private 私有的

5.instanceof和类型转换

instanceof

Student student=new Student();
System.out.println(student instanceof Student);//true
System.out.println(student instanceof Object);//true
System.out.println(student instanceof Person);//true
System.out.println(student instanceof Teacher);//false
System.out.println(student instanceof String);//false

类型转换
- 父类之间的转换子——父
```
Person  student=new Student();
```
  父——子
```
Student student=（student）student;
```
- student将这个对象转换为student类型就可以用student类型的方法了
- 子类转换为父类，可能丢失自己本来的一些方法
总结：
1. 父类引用指向子类的对象
2. 把子类转换为父类，向上转型
3. 把父类转换为子类，向下转型（强制转换）
4. 方便方法的调用，减少重复的代码

编程思想抽象：封装、继承和多态

6.static关键字详解

import static java.lang.Math.random;//静态导入包，可以指调用random()

public class Student {
    private static int age;//静态变量 ，可以直接使用 类名.age调用
    public static void go(){//静态构造器，可以直接使用 类名.go()方法调用
        System.out.println("我是静态构造器");
    }
    static {//静态代码块，最早执行，只执行一次
        System.out.println("我是静态代码块");
    }
    {//匿名代码块
        System.out.println("我是匿名代码块");
    }

    public static void main(String[] args) {
        Student student=new Student();
        System.out.println(student.age);
        student.go();
    }
}

在这里插入图片描述

7.抽象类

abstract修饰可以用来修饰方法也可以修饰类，如果修饰方法，那么该方法就是抽象方法；如果修饰类，那么该类就是抽象类
抽象类中可以没有抽象方法，但是有抽象的类一定要声明为抽象类
抽象类，不能使用new关键字来创建对象，它是用来让子类继承的
抽象方法，只有方法的声明，没有方法的实现，它是用来让子类实现的
子类继承抽象类，那么必须要实现抽象类没有实现的抽象方法，否则该子类也要声明为抽象类

思考题：1.抽象类不能new对象，存在构造器吗？ 2.抽象类存在的意义

8.接口的定义及实现

普通类：只有具体实现
抽象类：具体实现和规范（抽象方法）都有
接口：只有规范。自己无法写方法专业的约束、约束和实现分离：面向接口编程
接口的本质是契约
声明类的关键字是clas，声明接口的关键字是interface

接口都需要实现类
类可以实现接口 implements接口
实现了接口的类，就需要重写接口中的方法

多继承利用接口实现多继承

public interface UserService {
    //常量  public  static final
    int AGE=99;
    //接口中的所有定义的方法其实都是抽象的public abstract
    void add(String name);
}

作用：
1. 约束
2. 定义一些方法，让不同的人来实现
3. public abstract
4. public static final
5. 接口不能被实例化，接口中没有构造方法
6. implements可以实现多个接口
7. 必须要重写接口中的方法

9.N种内部类

内部类就是在一个类的内部定义一个类
内部类
1. 成员内部类
2. 静态内部类
3. 局部内部类
4. 匿名内部类

一个Java类中可以有多个class类，但是只能有一个public class

异常机制

1.Error和Exception

错误Error，异常Exception
Exception的分支：
- RuntimeException（运行时异常）
- ArrayIndexOutOfBoundsException（数组下标越界）
- NullPointerException（空指针异常）
- MissingResourceException（丢失资源）
- ClassNotFoundException（找不到类）
- …

2.捕获和抛出异常

异常处理五个关键字

try、catch、finally、throw、throws

结构

try {

}catch (){

}finally {

}
//try  监控区域，catch 捕获异常，finally 处理善后异常
//catch ()空号里为捕获的异常类型
//finally可以不要

最大的异常 Throwable
- 假设要捕获多个异常：从小到大
- 选中 ctrl+alt+T 可以添加try catch
- throw 主动抛出异常，一般在方法中使用
- throws 方法上抛出异常

3.自定义异常

用户自定义异常类，只需继承Exception类即可
实际应用中的经验总结
1. 处理运行时异常时，采用逻辑去合理规避同时辅助try——catch处理
2. 在多重catch块后面，可以加一个catch(Exception)来处理可能会被遗漏的异常
3. 对于不确定的代码，也可以加上try——catch，处理潜在的异常
4. 尽量去处理异常，切忌只是简单地调用printStackTrace()去打印输出
5. 具体如何处理异常，要根据不同的业务需求和异常类型去决定
6. 尽量添加finally语句块去释放占用的资源