Java面向对象 听课笔记

Java面向对象

super注意点

1. super调用父类的构造方法，必须在构造方法的第一个
2. super必须只能出现在子类的方法或者构造方法中
3. super和this不能同时调用构造方法

快捷键：

Fn + Alt + Insert

Ctrl + H

vs this

1. 代表的对象不同：

   this：本身调用者这个对象

   super：代表父类对象的应用

2. 前提

   this：没有继承也可以使用

   super：只能在继承条件下才可以使用

3. 构造方法

   this(); 本类的构造

   super(); 父类的构造

方法的重写

1. 静态方法的调用只和左边——定义的数据类型有关
2. 重写需要有继承关系额，子类重写父类的方法
3. 参数列表必须相同
4. 修饰符：范围可以扩大 public 》 Protected 》Default 》private
5. 抛出的异常：范围可以缩小，但不能扩大

为什么需要重写

1. 父类的功能，子类不一定需要，或者不一定满足

   加上注解@override即表示方法重写

多态

1. 一个对象的实际类型是确定的。

2. 可以指向的引用类型就不确定了：父类的引用指向子类

   Student s1 = new Student();

   Person s2 = new Student();

   Object s3 new Student();

   能执行哪些方法，主要看对象左边的类型，和右边关系不大

3. 多态是方法的多态，属性没有多态

4. 父类和子类，有关系的类 类型转换异常！ ClassCastException

5. 存在条件：继承关系，方法需要重写，父类引用指向子类对象

instanceof和类型转换

1. instanceof（类型转换） 引用类型，判断一个对象是什么类型，判断是否构成线性父子关系

抽象类（abstract）

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

接口

1. 普通类:只有具体实现；

   抽象类:具体实现和规范(抽象方法)都有!

   接口:只有规范!自己无法写方法_{专业的约束!约束和实现分离:面向接口编程}

2. 接口就是规范，定义的是一组规则，体现了现实世界中“如果你是…则必须能…”的思想。如果你是天使，则必须能飞。如果你是汽车，则必须能跑。如果你好人，则必须干掉坏人;如果你是坏人，则必须欺负好人。接口的本质是契约，就像我们人间的法律一样。制定好后大家都遵守。

3. 声明类的关键字是class,声明接口的关键字是interface。

4. 接口都需要有实现类（用implements）

5. 接口中的所有定义其实都是抽象的 public abstract

作用

1. 约束

2. 定义一些方法，让不同的人实现；

3. public abstract

   public static final

4. 接口不能被实例化，接口中没有构造方法

   接口是不可以被new的，但是有一种写法是 new Person(){}，似乎是接口被new了，其实不然，注意后面的{}，这其实是匿名内部类。

5. implements可以实现多个接口

6. 必须要重写接口中的方法

异常

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

2. 五个关键字： try、catch(括号中填入想要捕获异常类型)、finally、throw、throws

   异常类型：Error < Exception < Throwable

   假设要捕获多个异常，那么顺序要从小到大 快捷键：Ctrl + Alt + T

3. 抛出异常 throw throws

   public void ***() throws ArithmeticException{} ; 假设方法中，处理不了这个异常，方法上抛出异常。

   throw new ArithmeticException(); 主动的抛出异常，一般在方法中使用

自定义异常

步骤

1. 创建自定义异常类。

2. 在方法中通过throw关键字抛出异常对象。

3. 如果在当前抛出异常的方法中处理异常，可以使用try-catch语句捕获并处理;否则在方法的声明处通过throws关键字指明要抛出给方法调用者的异常，继续进行下一步操作。

4. 在出现异常方法的调用者中捕获并处理异常。

代码

//自定义的异常类
public class MyException extends Exception{
	//传递数字>10;
    private int detail;
    
    //写构造函数
    public MyException(int a){
        this.detail = a;
    }
    
    //toString:异常的打印信息
   @override
   public String toString()
   {
       return "MyException{"+ detail + '}';
   }
}

//测试类
public class Test{
    //可能会存在异常的方法
    static void test(int a) throws MyException{
        System.out.println("传递的参数为: "+a);
        if(a > 10)
        {
            throw new MyException(a);//抛出
        }
        System.out.println("OK");
    }
    
    public static void main(String[] args){
        try{
            test(11);
        }catch(MyException e){
            System.out.println("MyException=>"+e);
        }
    }
}

经验总结

• 处理运行时异常时，采用逻辑去合理规避同时辅助try-catch处理。
• 在多重catch块后面，可以加一个catch (Exception)来处理可能会被遗漏的异常对于不确定的代码，也可以加上try-catch，处理潜在的异常。
• 尽量去处理异常，切忌只是简单地调用printStackTrace()去打印输出扶f具体如何处理异常，要根据不同的业务需求和异常类型去决定
• 尽量添加finally语句块去释放占用的资源。

throw和throws的区别

throw和throws关键字

1. throws：如果有些异常你不想在这个方法里面捕获处理,就是在这个方法里面使用try…catch.那就使用throws,然后把这个异常交给调用它的人来处理–>所以通俗一点来说就是我不想处理这个异常。给上一级调用我的人处理把。
2. throw：如果你想在指定的位置就让它出你想要的异常,就用throw

throws

那么一般什么时候会用到throws？当有检查性异常出现的时候

这里面就有一个检查性异常,如果你不进行异常处理的话它就会编译报错
所以正常情况下你这么做??

就可以解决问题.但是如果我不想在这里这么做。这里好几行代码影响我阅读。这时候就可以用throws来把这个异常交给调用它的人处理,就像这样??

throws关键字用在方法名之后,多个异常用逗号隔开
我把这个异常交给main方法处理。所以main方法同样也要做出选择,是我处理还是在给上一级处理。如果是main方法自己处理,那么进行try…catch就可以。如果继续抛出??

最终变成了这个样子。这样的话这个异常就会交给JVM处理了,但是JVM没法处理啊。怎么办，那就报错中止程序喽。运行后变成下面这样?

到此，throws关键字的作用是什么？

在这个方法里有一个检查性异常。如果你不想捕获它。想交给调用它的上一级处理就使用throws抛出相应的异常。

–>这样用throws有什么好处？
1,如果多个方法会出同一个检查性异常。它的调用者都是同一个人。那就没必要一个一个处理了。统一处理就好。就像下面这样.

public static void main(String[] args) throws FileNotFoundException {
            fun();
            fun1();
    }
    
public static void fun() throws FileNotFoundException {
        FileInputStream fileInputStream = new FileInputStream(new File(""));
}

public static void fun1() throws FileNotFoundException {
    FileInputStream fileInputStream = new FileInputStream(new File(""));
}

2,减少代码量提高阅读性。–>同样的功能代码量少大多都是好的。它还可能提升阅读性

throw

什么时候用throw?当你要在指定的位置就让它出异常的时候用throw.

public static void main(String[] args) {       
	fun();
} 
public static void fun() {
//手动抛出一个NullPointerException异常
	throw new NullPointerException("出了个异常");
}

运行结果如下：

throw用在方法中.而且一次只能丢一个异常。

 public static void main(String[] args) {
           fun(1,0);
    }
    public static void fun(int num1,int num2) {
        if(num2==0){
            throw new ArithmeticException("除数不能为0");
        }else {
            System.out.println(num1/num2);
        }
    }

上一节我对这个1/0的异常用了捕获处理。这次这边用throw来处理.来告诉调用者你出错了。
当你要在指定的位置就让它出异常的时候用throw.
这样的想法什么时候会有,就是你要告诉调用者如果做了违背你使用方法的时候给它出一个异常来告诉调用者这么用错了。
throw倾向于调用者。它并不是说把这个异常处理了。而且要告诉调用者不能这么做。不然会出异常。

throw和throws的区别

到这应该就能说出一点它们的区别了了。

1. 使用上的区别.throw用在方法体中。且一次只能抛一个.throws用在方法名后面。一次能抛出多个
2. 使用目的不同。throw多用在告诫调用者不能这么做。throws是把这个方法会出的异常丢给上一级处理。

总结:

1. throws是什么？
   异常处理的一种方式,如果不想在这个方法捕获异常,那就throws给上一级来处理
2. throws怎么用?一般什么时候用？
   写在方法名后面,可以一次抛出多个异常。一般用在检查性异常上
3. throw是什么？
   也是一种异常处理方法。如果要在指定的地方主动让它出异常,就用throw.
4. throw怎么用？一般什么时候用?
   throw写在方法体中.一次只能抛出一个异常。一般用在要告诫调用者这么用会出异常的时候。throw一下
5. throws和throw的区别?
   使用上的区别和使用目的的区别。根据这两个方向来说能让你更好的理解它们的区别