Day06

小白求学路、

已于 2023-03-29 17:49:49 修改

阅读量37

点赞数

文章标签： java

于 2023-03-29 17:45:24 首次发布

本文链接：https://blog.csdn.net/qq_57802994/article/details/129841635

版权

多态

动态编译：类型：可扩展性。
即同一方法可以根据发送对象的不同而采用多种不同的行为方式。
一个对象的实际类型是确定的，但可以指向对象的引用的类型有很多（父类，有关系的类）。
多态存在的条件：
1. 有继承关系
2. 子类重写父类的方法
3. 父类的引用指向子类
多态是方法的多态，属性没有多态性。
instanceof 判断两个对象是否有父子关系 // (类型转换) 引用类型吗，判断对象是什么类型

（父类可以调用子类重写了父类的方法，子类可以调用父类“所有”的方法前提：父类的引用指向子类；小的用大的“所有”，大的用小的重写的，父类引用不指向只能用自己的。demo07）

小结：// demo08

1.父类引用指向子类的对象
2.把子类转换为父类，向上转型； 可能会丢失自己本来的方法
2.把父类转换为子类，向下转型； 强制转换
4.方便方法的调用，减少重复的代码！简洁

抽象： 封装、继承、多态！   抽象类，接口

static关键字

方法调用：

静态或非静态间可互相调用,非静态可调静态，静态不可调非静态。 // 静态与类一起加载

{
    // 代码块（匿名代码块）
}

static {
    // 静态代码块（加载初始化的数据）  只执行一次
}
// 执行先后顺序
// 静态代码块——>匿名代码块——>构造方法
// 静态导入包  导入后在main中可直接用这些方法  
import static java.lang.Math.random;
import static java.lang.Math.PI;
// final声明后 断子绝孙
// demo09

抽象类

// abstract 抽象类：类 extends：  单继承~    (接口可以多继承)
// 约束~有人帮我们实现~
// abstract 抽象方法，只有方法名字，没有方法的实现！
// 抽象类的所有方法，继承了它的子类，都必须要实现他的方法~ 除非子类也是一个抽象类——>子子类去实现

// 1.不能 new 这个抽象类，只能靠子类去实现它：约束！
// 2.抽象类中可以写普通方法
// 3.抽象方法必须在抽象类中
// 抽象的抽象：约束

// 思考题？ 不能 new ，存在构造器？
// 存在的意义？   提高开发效率，可扩展性高
// demo10

接口

普通类：只有具体实现
抽象类：具体实现和规范（抽象方法）都有
接口：只有规范，无方法。专业的约束！约束和实现分离：面向接口编程
1. 接口就是规范，定义的是一组规则。
2. 接口的本质是契约，就像法律一样，制定好后大家都要遵守
3. OO的精髓，是对对象的抽象，最能体现这一点的就是接口。对设计模式的研究就是如何合理的去抽象。
4. 声明类的关键字是class，声明接口的关键字是interface

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

内部类

内部类就是在一个类的内部在定义一个类，如：A类中定义一个B类，B类相对A类来说就是内部类，A类相对B类来说就是外部类。

成员内部类

// 成员内部类
public class Outer{
    public class Inner {
        public void in() {
            System.out.println("这是内部类的方法");
        }

        // 获得外部类的私有属性、私有方法
        public void getID() {
            System.out.println(id);
        }
    }
}
// 通过这个外部类来实例化内部类
//  Outer.Inner inner = outer.new Inner();
//  inner.getID();

静态内部类

// 静态内部类
public class Outer{
    public static class Inner {
        public void in() {
            System.out.println("这是内部类的方法");
        }

    }
}

局部内部类

内部类在方法中
匿名内部类

没有名字初始化类，不用将实例保存到变量中

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

异常机制 Exception

什么是异常

实际工作中，遇到的情况不可能是非常完美的。比如：你写的某个模块，用户输入不一定符合你的要求、你的程序要打开某个文件，这个文件可能不存在或者文件格式不对，你要读取数据库的数据，数据可能是空的。等等

软件程序在运行过程中，非常可能遇到刚刚提到的这些异常问题，即：Exception。

异常指的程序运行中出现的不期而至的各种状况。

异常发生在程序运行期间，它影响了正常的程序执行流程。
简单分类
- 检查性异常：最具代表性的检查异常是用户错误或问题引起的异常，这是程序员无法预见的。例如要打开一个不存在的文件时，一个异常就发生了，这些异常在编译时不能被简单地忽略。
- 运行时异常：运行时异常是可能被程序员避免的异常。与检查异常相反，运行时异常可以在编译时被忽略。
- 错误error：错误不是异常。

在这里插入图片描述
3. Exception

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

Error

Error类对象由java虚拟机生成并抛出，大多数错误与代码编写者所执行的操作无关。
java虚拟机运行错误Virtual Machine Error,当JVM不再有继续执行操作所需的内存资源时，将出现OutOfMemoryError。这些异常发生时，java虚拟机（JVM）一般会选择线程终止；
还有发生在虚拟机试图执行应用时，如类定义错误NoClassDefFoundError、链接错误LinkageError。这些错误是不可查的，因为它们在应用程序的控制和处理能力之外，而且绝大多数是程序运行时不允许出现的状况。

Exception

Exception——>RuntiomException（运行时异常）：
- ArrayIndexOutOfBoundsException（数组下标越界）
- NullPointerException（空指针异常）
- ArithmeticException（算术异常）
- MissingResourceException（丢失资源）
- ClassNotFoundException（找到不类）
这些异常是不检查异常，程序中可以选择捕获处理，也可以不处理。逻辑错误引起

Error和Exception的区别：Error是程序无法控制和处理的——>JVM 一般会选择终止线程；Exception通常是可以被程序处理的。
6. 异常处理机制
1. 抛出异常
2. 捕获异常

        int a = 1；
        int b = 0；
        // 假设要捕获多个异常： 从小到大！
        try { // try 监控区域
            if (b==0){ // 主动抛出异常 throw  throws   但一般用在方法中
                throw new ArithmeticException();  
            }
            System.out.println(a/b);

        }catch (Error e){ // catch(想要捕获的异常类型！) 捕获异常  Throwable为最高类型
            System.out.println("Error");
        }catch (Exception e){
            System.out.println("Exception");
        }catch (Throwable t){
            System.out.println("Throwable");
        } finally { // 处理善后工作
            System.out.println("finally");
        }

        // finally 可以不要，       假设IO，资源等，就在这个代码块里关闭！

public static void main(String[] args) {
    int a = 1;
    int b = 0;

    try {
        new Test().test(1,0);
    } catch (ArithmeticException e) {
        e.printStackTrace();
    }
	
}

// 方法向上抛出异常 调用时需要捕获
public void test ( int a, int b) throws ArithmeticException{
    if (b == 0) { // 主动抛出异常  throw  (throws 向上抛出异常)   一般在方法中使用
        throw new ArithmeticException();
    }
    System.out.println(a / b);
}

如果没有捕获异常，程序到异常位置就结束了，捕获异常然后对异常进行处理，程序正常运行

异常处理关键字：

try、catch、finally、throw、throws

7. **自定义异常**
 * 使用java内置的异常类可以描述在编程时出现的大部分异常情况。此外，用户还可以自定义异常类，只需要**继承Exception**即可。
 * **自定义异常步骤**：demo02
   1. 创建自定义异常类
   2. 在方法中通过throw关键字抛出异常对象
   3. 如果在当前抛出异常的方法中处理异常，可以使用try-catch语句捕获并处理；否则在方法的声明处通过throws关键字指明要抛出给方法调用者的异常，继续下一步操作
   4. 在出现异常方法的调用者中捕获并处理异常