526互联

Java学习日记3

发布时间 2023-03-29 19:57:37作者: s1mpLe丶Han

2023.3.28学习Java打卡

封装

禁止直接访问一个对象中数据的实际表示，应通过操作接口来访问。

程序设计要求”高内聚，低耦合“。

高内聚：类的内部数据操作细节由自己完成，不允许外部干涉。

低耦合：暴露少量的方法给外部使用。

  • 特点：
    • 提高程序安全性，保护数据
    • 隐藏代码的实现细节
    • 统一接口
    • 增加系统可维护性

继承

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

super

  • super调用父类构造方法，且只能在构造方法第一个
  • super只能出现在子类方法或构造方法中
  • super和this不能同时调用构造方法
  • super与this
    • this：调用本身的对象；无继承关系可使用
    • super：代表父类对象的引用；必须有继承关系才能使用

方法重写

  • 需要有继承关系，子类重写父类法方法（只针对方法）！
  • 方法名必须相同
  • 参数列表相同
  • 修饰符范围可以扩大，不能缩小（例：public→private不可以，private→pubilc可以）
  • public > protected > default > priavte
  • 为什重写？
    • 父类功能，子类不一定需要，或不一定满足

多态

通过多态，增强可拓展性。

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

注意：

  • 多态是方法的多态，属性无多态
  • 需要有继承关系，方法需重写
  • static、final、private无法被重写

instanceof

package DuoTai;

public class Main {
    public static void main(String[] args) {
/*        //父类的引用指向子类
        Object object = new Student();
        //Student s1 = new Student();
        System.out.println(object instanceof Student);
        System.out.println(object instanceof Person);
        System.out.println(object instanceof Object);
        System.out.println(object instanceof Teacher);
        System.out.println(object instanceof String);
        System.out.println("============================");
        Person person = new Student();

        System.out.println(person instanceof Student);
        System.out.println(person instanceof Person);
        System.out.println(person instanceof Object);
        System.out.println(person instanceof Teacher);
        //System.out.println(person instanceof String);
        System.out.println("============================");
        Student student = new Student();
        System.out.println(student instanceof Student);
        System.out.println(student instanceof Person);
        System.out.println(student instanceof Object);
        //System.out.println(student instanceof Teacher);
        //System.out.println(student instanceof String);*/

        //类型之间的转换，高-----→低
        //             父-----→子
        Person student1 = new Student();
        //student.go();
        //将student改为Student类型，就可使用Student类方法
        Student student2 = (Student) student1;
        student2.go();                        //可用((Student) student1).go();代替
    }
}
  • 父类引用指向子类对象
  • 把子类转换为父类，叫向上转型
  • 把父类转换为子类，叫向下转型，强制转换会丢失方法
  • 方便方法的调用，减少重复的代码，简洁

static

public class Person {
/*    {
        //匿名代码块
    }
    static {
        //静态代码块
    }*/
    {
        System.out.println("匿名代码块");
    }
    static {
        System.out.println("静态代码块");
    }
    public Person(){
        System.out.println("方法代码块");
    }

    public static void main(String[] args) {
        Person person = new Person();
    }
}

输出：
    静态代码块
    匿名代码块
    方法代码块

抽象类

  • abstract修饰符可以用来修饰方法或修饰类。若修饰方法，则该方法为抽象方法；若修饰类，则该类为抽象类
  • 抽象类中可以没有抽象方法，可以写普通方法，但有抽象方法****的类一定要声明为抽象类
  • 抽象类的所有方法必须要由子类实现

接口

  • 接口就是规范，定义的是一组规则。
  • 接口的精髓，是对对象的抽象，最能体现这一点的就是接口。
  • 实现了接口类，就要重写接口中的方法。
  • 可以利用接口实现多继承
  • 接口常量：public static final ...
  • 接口作用：
    • 起到约束作用
    • 定义一些方法，让不同的人实现
    • public abstract 接口名
    • public static final 方法类型 方法名
    • 接口不能被实例化，接口中没有构造方法
    • implements可以实现多个接口
    • 必须要重写接口中的方法

内部类

在一个类的内部再定义一个类。例：A类中定义一个B类，那么B类相对于A类来说就是内部类，而A类相对于B来说就是外部类。

例：

public class Outer {

    private int id = 10;
    public void out(){
        System.out.println("这是外部类的方法");
    }
    class Inner{
        public void in(){
            System.out.println("这是内部类的方法");
        }
        public void getID(){
            System.out.println(id);
        }
    }
}

public class Main {
    public static void main(String[] args) {
        Outer outer = new Outer();
        //通过外部类来实例化
        Outer.Inner inner = outer.new Inner();
        inner.in();
        inner.getID();
    }
}

异常机制

  • 检查性异常：用户错误或问题引起的异常，这是程序员无法预见的。
  • 运行时异常：可能被程序员避免的异常。与检查性异常相反，运行时异常可以在编译时被忽略。
  • 错误ERROR：错误不是异常，是脱离程序员控制的问题。错误在代码中常常被忽略。

抛出异常

捕获异常

异常处理五个关键字

  • try
  • catch
  • finally
  • throw
  • throws

自定义异常

步骤如下：

  • 创建自定义异常类
  • 在方法中通过throw关键字抛出异常对象
  • 如果在当前抛出异常的方法中处理异常，可以使用try—catch语句捕获并处理；否则在方法的声明处通过throws关键字指明要抛出给方法调用者的异常，继续进行下一步操作。
  • 在出现异常方法的调用者中捕获并处理异常。
  • 经验总结：
    • 处理运行异常时，采用逻辑去合理规避同时辅助try-catch处理
    • 在多重catch块后面，可以加上一个catch（Exception）来处理可能会被遗漏的异常。
    • 对于不确定的代码，也可以加上try-catch，处理潜在的异常。
    • 尽量去处理异常，切记只是简单的调用printStackTrace()去打印输出。
    • 具体如何处理异常，要根据不同的业务需求和异常类型去决定。
    • 尽量添加Finally语句块去释放占用的资源。