复习JavaDay05
static关键字
static不能随便使用，因为它会在类加载时同类一起加载，而普通方法会在类加载完毕后才会执行，会导致结果出现问题
package com.softeem.entity;
import static java.lang.Math.random;
import static java.lang.Math.PI;
public class Applicasion {
//没有静态方法的话最先执行
public Applicasion() {
System.out.println("无参构造方法");
}
//匿名代码块除静态代码块外最先执行，作用于赋初始值
{
System.out.println("匿名代码块");
}
//跟类一同加载，程序运行时最先执行，且只在类加载完时执行一次
static {
System.out.println("静态代码块");
}
public static void main(String[] args) {
double a = (random() * 100);
System.out.println("静态包导入可直接使用" + (int) a);
System.out.println("静态包导入可直接使用" + PI);
new Applicasion();
}
}
抽象类
抽象类 abstract修饰符可以用来修饰方法也可以修饰类，如果修饰方法，那么该方法就是抽象方法；如果修饰类，那么该类就是抽象类 抽象类中可以没有抽象方法，但是有抽象方法的类一定要声明为抽象类 抽象类，不能使用new关键字来创建对象，它是用来让子类继承的 抽象方法，只有方法的声明，没有方法的实现，它是用来让子类实现的 子类继承抽象类，那么就必须要实现抽象类没有实现的抽象方法，否则该子类也要声明为抽象类
抽象类的方法必须要由继承它的子类来实现。
抽象类不能被实例化（new），只能由继承它的子类去实现：约束！
抽象类中可以写普通的芳芳。抽象方法必须在抽象类中。
思考：抽象类存在的意义？ 存在的意义在于初始化数据，降低代码重复量，节省空间。
new，存在构造器吗？实践得出是存在构造器，调用了无参构造方法
//abstract 抽象类
public abstract class Person {
//抽象类的抽象方法不需要有实现，只需被继承的子类实现即可
public abstract void person();
public Person() {
System.out.println("执行了吗");
}
}
public class Student extends Person{
//父类写的抽象方法子类必须重写实现，重写时会调用父类中的抽象方法和构造器
@Override
public void person() {
System.out.println("???");
}
public static void main(String[] args) {
//输出结果时父类中的构造方法输出了执行了，并也输出了子类中重写的person方法
new Student().person();
}
}
继承implements关键字
//通过implements关键字实现对接口方法的实现，接口可以实现伪多继承，有多个implements即可
public class PersonImpl implements Person{
内部类
//内部内的使用
public class Person {
private int id = 10;
public void test() {
System.out.println("这里执行说明被内部内方法调用");
}
class Person1 {
public void test1() {
test();
System.out.println("这是内部内的方法，输出外部内中的属性id为：" + id);
}
}
}
public class Applicasion {
public static void main(String[] args) {
//实例化Person类
Person person = new Person();
//用实例化后的Person类去new Person1这个内部类
//该句自我理解为父类的引用指向子类空间，像是多态
Person.Person1 person1 = person.new Person1();
//调用Person1类中的test1方法
person1.test1();
}
}
//====================手动分割线，跟以上无关=====================
public void test() {
class A{
public void test(){
System.out.println("这是局部内部类，见识即可");
}
}
}
//====================手动分割线，跟以上无关=====================
//匿名内部内的使用
public class Person {
public static void main(String[] args) {
//不需要把这个类给予名称，不需要在其他地方使用，这个称之为匿名内部类
new A().test();
}
}
class A{
public void test(){
System.out.println("测试匿名内部类");
}
}
Error和Exception
异常有以下几种，一般是由代码编写问题抛出
RuntimeException：运行时异常
ArrIndexOutBoundsException：下标越界异常
NullPointerException：空指针异常
ArithmeticException：算数异常
MissingResourceException：丢失资源
ClassNotFoundException：找不到类
Error
当JVM不再有继续执行操作所需的内存资源时，将出现OutOfMemoryError
...
总结：Error是灾难性的致命的错误，是程序无法控制和处理的，当出现这些异常时，Java虚拟机一般会终止线程。
Exception通常情况下是可以被程序处理的，并且在程序中应该尽可能的去处理这些异常。
捕获和抛出异常
异常处理的五个关键字：try，catch，finally，throw，throws。
如需要捕获多个异常，应遵循从小到大的异常去捕获
//快捷键Ctrl+Alt+t 选择try，catch，finally
//这样执行会出现算数异常，因为0不能成为被除数
int a = 1;
int b = 0;
System.out.println(a / b);
try {
System.out.println(b/a);
}catch (ArithmeticException e){
System.out.println("算数异常了,被除数不能等于0");
//finally可以没有，不过一般在使用io流或者开启资源时需要关闭时会用到finally关闭资源
}finally {
System.out.println("finally必须执行");
}
int a = 0;
int b = 1;
try {
System.out.println(b/a);
//Throwab是最大的异常，可以捕获到Error和Exception的任何错误
}catch (Throwable t){
System.out.println("算数异常了,被除数不能等于0");
}finally {
System.out.println("finally必须执行");
}
//如需要捕获多个异常，catch应遵循从小到大的异常去捕获，以下举例
try {
new Test1().a();
} catch (Exception t) {
System.out.println("出现异常");
} catch (Error e) {
System.out.println("出现错误");
} catch (Throwable e) {
System.out.println("上面已经处理，不会执行到这里");
} finally {
System.out.println("finally必须执行");
}
}
//以下两个死循环
public void a() {
b();
}
public void b() {
a();
}
int a = 1;
int b = 0;
//快捷键Ctrl+Alt+t 选择
try {
System.out.println(a / b);
} catch (Exception e) {
//打印错误信息（可以不要）
e.printStackTrace();
//这里可以输出我们自己的业务逻辑：例如以下的系统退出方法，返回编码为0
System.exit(0);
} finally {
System.out.println("必须执行的");
}
主动抛出异常的好处在于处理了异常后程序会继续运行
public static void main(String[] args) {
//主动抛出异常的好处在于处理了异常后程序会继续运行
try {
new Test2().test(1, 0);
} catch (Exception e) {
//打印错误信息
e.printStackTrace();
}
System.out.println("这里的好处在于主动抛出异常处理了后程序会继续运行");
}
//假设在这个方法中，处理不了这个异常，方法上抛出异常
public void test(int a, int b) throws Exception {
if (b == 0) {
throw new Exception(); //主动抛出异常，一般在方法中使用
}
}
自定义异常
Java中，所有对象默认继承了Objct，如果没有重写toString方法，默认调用Objct对象的toString()方法
public class MyExseption extends Exception {
//定义一个属性用来接收值
private int number;
//有参构造用来传入值
public MyExseption(int number) {
this.number = number;
}
//Java中，所有对象默认继承了Objct，如果没有重写toString方法，默认调用Objct对象的toString()方法
@Override
public String toString() {
return "自定义异常错误值为：{" +
+ number +
'}';
}
}
public class Test {
//定义一个可能会出现异常的方法，例如如果输入大于10就抛出异常
public void test(int a) throws MyExseption {
System.out.println("传递的参数值为："+a);
//如果传入过来的参数大于10就主动抛出异常
if (a > 10) {
//实例化我的自定义异常类并抛出
throw new MyExseption(a);
}
System.out.println("OK");
}
public static void main(String[] args) {
try {
//调用上方test（）方法
new Test().test(91);
} catch (MyExseption e) {
//增加一些处理异常的代码，例如输入的大于10，就让输入的等于10.。。
//打印错误信息
System.out.println(e);
}
}
}
结论：控制台输出如下：
传递的参数值为：91 自定义异常错误值为：{91}
异常总结：
处理运行时异常时，采用逻辑去合理规避，同时辅助try-catch处理 在多重catch块后面， 可以加一个catch （Exception） 来处理可能会被遗漏的异常 对于不确定的代码，也可以加上try-catch，处理潜在的异常 尽量去处理异常，切忌只是简单地调用 printStackTraceO去打印输出 具体如何处理异常，要根据实际的业务需求和异常类型去决定 尽量添加finally语句块去释放占用的资源
浙公网安备 33010602011771号