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语句块去释放占用的资源。