instanceof

类型转换

子类是父类的一个实例，而父类不一定是子类的一个实例，所以在父类向子类转型时，要强制类型转换。

父类如果想用子类的方法就需要强制类型转换

package oop;

import oop.demo06.Person;
import oop.demo06.Student;
import oop.demo06.Teacher;
//已知Student和Teacher都是Person的子类
public class Application {
    public static void main(String[] args) {
        //类型之间的转化：  父  子
        
        Person obj = new Student();
        
        //obj是Person引用的 想调用其子类Student的go方法，就需要强制类型转化
        //obj.go(); 报错
        ((Student) obj).go();

    }
}

static关键字

package oop.demo07;

//static
public class Student {
    
    private static int age;//静态的变量  多线程!
    private double score;//非静态的变量


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

        //静态变量可以用类名直接调用变量名  非静态的则不能，只能通过将类进行实例化
        System.out.println(Student.age);
//        System.out.println(Student.score);报错
        System.out.println(s1.age);
        System.out.println(s1.score);

    }
}

package oop.demo07;

//static
public class Student {
    
    private static int age;//静态的变量  多线程!
    private double score;//非静态的变量

    public void run(){

    }

    public static void go(){

    }


    public static void main(String[] args) {
        go();//可以直接调用静态方法


        Student s1 = new Student();
        s1.run();//实例化后才可以使用

    }
}

package oop.demo07;

import static java.lang.Math.random;//静态导入包
public class Test {
    public static void main(String[] args) {
        System.out.println(random());//静态导入包后，可以直接用
    }
}

抽象类

package oop.demo08;

//abstract 抽象类：类 extends:单继承   （接口可以多继承）
public abstract class Action {

    //约束，有人帮我们实现
    //abstract，抽象方法，只有方法名字，没有方法的实现！
    public abstract void doSomething();

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

package oop.demo08;

//抽象类的所有方法，继承了它的子类，都必须要实现它的方法
public class A extends Action {
    @Override
    public void doSomething() {

    }
}

思考：1.抽象类既然不能new，那么它存在构造器吗？

2.抽象类存在的意义是什么？

1.存在。

抽象类虽然不能直接通过 new 关键字实例化，但它仍然可以拥有构造器。这些构造器的作用是：

在子类实例化时，会先调用父类（抽象类）的构造器完成父类成员的初始化
抽象类的构造器通常用于初始化抽象类中定义的字段或执行一些公共初始化逻辑

abstract class AbstractClass {
    protected String name;
    
    // 抽象类的构造器
    public AbstractClass(String name) {
        this.name = name;
    }
    
    public abstract void doSomething();
}

class ConcreteClass extends AbstractClass {
    // 子类必须调用父类的构造器
    public ConcreteClass(String name) {
        super(name); // 调用抽象类的构造器
    }
    
    @Override
    public void doSomething() {
        System.out.println("Doing something: " + name);
    }
}

2.抽象类的核心意义是为子类提供公共的模板和规范，具体体现在：

代码复用

抽象类可以定义子类共有的属性和方法实现，避免子类重复编写相同代码。
规范约束

通过抽象方法（只有声明没有实现）强制子类必须实现特定功能，保证了子类的行为一致性。
层次设计

在类的继承体系中，抽象类通常作为中间层，体现了 "抽象→具体" 的设计思想，使类结构更清晰。
多态基础

抽象类可以作为引用类型指向子类对象，实现多态特性，提高代码的灵活性和扩展性。

例如，在图形绘制系统中，抽象类 Shape 可以定义所有图形共有的 getArea() 方法声明，而具体的 Circle、Rectangle 等子类则实现各自的面积计算逻辑。

接口

普通类：只有具体实现
抽象类：具体实现和规范（抽象方法）都有！
接口：只有规范！自己无法写方法--专业的约束！约束和实现分离：面向接口编程
接口就是规范，定义的是一组规则，体现了现实世界中“如果你是...则必须能...”的思想。如果你是天使，则必须能飞。如果你是汽车，则必须能跑。如果你好人，则必须干掉坏人；如果你是坏人，则必须欺负好人。
接口的本质是契约，就像我们人间的法律一样。制定好后大家都遵守。
面向对象的精髓，是对对象的抽象，最能体现这一点的就是接口。为什么我们讨论设计模式都只针对具备了抽象能力的语言（比如C++、java、c#等），就是因为设计模式所研究的，实际上就是如何合理的去抽象。

接口作用：

约束
定义一些方法，让不同的人实现
public abstract
接口不能被实例化，接口中没有构造方法
implements可以实现多个接口
必须要重写接口中的方法

内部类

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

第一种成员内部类：

public class Outer{
    
}
//一个java类中可以有多个class类，但是只能有一个public class
class A{
    
}

第三种局部内部类：

public class Outer{
    
    //局部内部类
    public void method(){
        class Inner{
            
        }
    }
}

第四种匿名内部类：

异常

实际工作中，遇到的情况不可能是非常完美的。比如：你写的某个模块，用户输入不一定符合你的要求、你的程序要打开某个文件，这个文件可能不存在或者文件格式不对，你要读取数据库的数据，数据可能是空的等。我们的程序再跑着，内存或硬盘可能满了等等。
软件程序再运行过程中，非常可能遇到刚刚提到的这些异常问题，我们叫异常，英文是：Exception，意思是例外。这些，例外情况，或者叫异常，怎么让我们写的程序做出合理的处理。而不至于程序崩溃。
异常指程序运行中出现的不期而至的各种状况，如：文件找不到、网络连接失败、非法参数等。
异常发生在程序运行期间，它影响了正常的程序执行流程。

简单分类

要理解Java异常处理是如何工作的，你需要掌握以下三种类型的异常：
- 检查性异常：最具代表的检查性异常是用户错误或问题引起的异常，这是程序员无法预见的。例如要打开一个不存在的文件时，一个异常就发生了，这些异常在编译时不能被简单地忽略
- 运行时异常：运行时异常是可能被程序员避免的异常。与检查性异常相反，运行时异常可以在编译时被忽略。
- 错误：错误不是异常，而是脱离程序员控制的问题。错误的代码中通常被忽略。例如，当栈溢出时，一个错误就发生了，它们在编译也检查不到的。

异常体系结构

Error

Exception

捕获异常

选中出错的语句快捷键 Ctrl + Alt +t


public class Test2 {
    public static void main(String[] args) {
        int a = 1;
        int b = 0;
        //快捷键 ctrl + alt + t
        try {
            System.out.println(a/b);
        } catch (Exception e) {
            throw new RuntimeException(e); // 打印错误的栈信息
        } finally {
        }
    }
}

package exception;

public class Test2 {
    public static void main(String[] args) {
        new Test2().test(1,0);
    }

    //假设这个方法中，处理不了这个异常。方法上抛出异常
    public void test(int a,int b) throws ArithmeticException{
        if (b == 0){
            throw new ArithmeticException();//主动的抛出异常，一般在方法中使用
        }
    }
}

posted on 2025-09-28 21:33 齐天大圣951 阅读(9) 评论(0) 收藏举报

刷新页面返回顶部