第四天面向对象

static关键字用来声明静态方法或是静态属性

同一个类中静态方法间可以直接调用，而静态方法不能直接调用非静态方法。需要先new一个对象，通过对象来调用。

而非静态方法可以直接直接调用静态方法。

而对于静态属性，可以直接赋值或是通过类名.属性名赋值，无论是否是静态方法中或是非静态方法中。

静态方法时跟随类一起加载的

static的方法仅能调用其他的static 方法，只能访问static数据，不能以任何方式引用this 或super。

这里当个复习点自己写了一遍关于static修饰的作用。

1.Super

• 子类与父类方法名相同，构成重写，父类该方法自动隐藏。

super注意点

1. super调用父类的构造方法，必须在构造方法的第一个

2. super 必须只能出现在子类的方法或构造方法中

3. super 和 this 不能同时调用构造方法

this

代表的对象不同

this： 本身调用者这个对象

super： 代表父类对象的引用

前提

this： 没有继承也可以视同

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

构造方法

this()： 本类的构造

super()： 父类的构造

2.方法的重写

在静态方法中 方法的调用只和左边定义的数据类型有关

即b是A new出来的对象。因此调用了A的方法。因为静态方法是类的方法。而非静态是对象的方法。有static时，b调用了B类的方法,因为b是用b类定义的没有static时，b调用的是对象的方法，而b是用A类new的

重写： 需要有继承关系，子类重写父类的方法；

1. 方法名必须相同

2. 参数列表必须相同

3. 修饰符：范围可以扩大：public--->Proctected--->Default--->private

4. 抛出的异常：范围，可以被缩小，但不能扩大。 ClassNotFoundException

重写： 子类的方法和父类必要一致，方法体不同

为什么需要重写：

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

2. Alt+insert：override

public class Person {
    protected String name = "ren";
?
    public Person(){
        super();
        System.out.println("Person无参执行了");
    }
?
    protected void print(){
        System.out.println("Person");
    }
}
?
public class Student extends Person{
    private String name = "renya";
?
?
?
    public Student(){
        System.out.println("Studen无参执行了");
    }
?
    public void print(){
        System.out.println("Student");
    }
?
    public void text(String name){
        System.out.println(name);
        System.out.println(this.name);
        System.out.println(super.name);
    }
    public void text1(){
        print();
        this.print();
        super.print();
    }
?
}
?
public static void main(String[] args) {
        Student student = new Student();
?
        student.text("ya");
        
        student.text1();
    }

3.多态

• 即同一方法可以根据发送对象的不同而采用多种不同的行为方式。一个对象的实际类型是确定的，但可以指向对象的引用的类型有很多

• 多态存在的条件

  • 有继承关系

  • 子类重写父类方法父类引用指向子类对象

• 注意:多态是方法的多态，属性没有多态性。

• instanceof

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

2. 父类和子类，有联系。 ClassCastException

3. 存在的条件：继承关系， 方法需要重写 父类引用指向子类对象 Father f1 = new Son();

4. static静态 final常量 private私有：均不能被重写

public class Person {
    String name;
    String food;
?
    public void eat(){}
}
?
public class Chinese extends Person {
    String name = "中国人";
    String food = "饺子";
?
    @Override
    public void eat() {
        System.out.println(name+"爱吃"+food);
    }
}
?
public class Russian extends Person {
    String name = "俄罗斯人";
    String food = "不知道";
?
    @Override
    public void eat() {
        System.out.println(name+"爱吃"+food);
    }
}
?
public class Text {
    public static void main(String[] args) {
        Text text = new Text();
        text.eatText(new Chinese());
        text.eatText(new Russian());
    }
    public void eatText(Person person){
        person.eat();
    }
}
?
output:
中国人爱吃饺子
俄罗斯人爱吃不知道

4.instanceof

object object = new student( );
System.out.println(object instanceof Student); //true
System.out.print1n(object instanceof Person); //true
System.out.println(object instanceof object); //true
System.out.println(object instanceof Teacher); //False
System.out.println(object instanceof String); //False
?
System.out.println( "==================—===============");
Person person = new Student();
System.out.println(person instanceof Student); //true
System.out.println(person instanceof Person); //true
System.out.println(person instanceof object); //true
System.out.println(person instanceof Teacher); //False
//System.out.printLn(person instanceof string);//编译报错!
System.out.println("==================================");
?
Student student = new Student();
System.out.println(student instanceof Student); //true
System.out.println( student instanceof Person); //true
System.out.println(student instanceof object); //true
//System.out. println(student instanceof Teacher);//编译报错!
//System.out.println(student instanceof String);//编译报错!
?

5.static关键字

static关键字用来声明静态方法或是静态属性

同一个了类中静态方法间可以直接调用，而静态方法不能直接调用非静态方法。需要先new一个对象，通过对象来调用。

而非静态方法可以直接直接调用静态方法。

而对于静态属性，可以直接赋值或是通过类名.属性名赋值，无论是否是静态方法中或是非静态方法中。

public class Student {
?
    private static String name;
    private int age;
?
    public static void run(){
        name = "ren";   //静态属性直接复制
        Student student = new Student();
        student.go();   //需要new对象调用非静态方法
    }
?
    public void go(){
        run();  //直接调用静态方法
        name = "ren";
        Student student = new Student();
        student.age = 1;    //非静态属性new对象来赋值
    }
?
    public static void main(String[] args) {
        Student.name = "ren";
?
    }
}

代码块：

public class Person {
?
    //匿名代码块 2.
    {
        System.out.println("这是匿名代码块");
    }
?
    //静态代码块 1.可以用来赋初值
    static {
        System.out.println("这是静态代码块");
    }
?
    //构造方法 3.
    public Person(){
        System.out.println("这是构造方法");
    }
?
    public static void main(String[] args) {
        Person person = new Person();
        System.out.println("==============");
        Person person1 = new Person();
    }
}
?
output:
这是静态代码块
这是匿名代码块
这是构造方法
==============
这是匿名代码块
这是构造方法

6.抽象类

• abstract修饰符可以用来修饰方法也可以修饰类,如果修饰方法,那么该方法就是抽象方法;如果修饰类,那么该类就是抽象类。

• 抽象类中可以没有抽象方法,但是有抽象方法的类一定要声明为抽象类。

• 抽象类,不能使用new关键字来创建对象,它是用来让子类继承的。

• 抽象方法,只有方法的声明,没有方法的实现,它是用来让子类实现的。

• 子类继承抽象类,那么就必须要实现抽象类没有实现的抽象方法,否则该子类也要声明为抽象类。

7.接口

• 普通类:只有具体实现

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

• 接口:只有规范!

• 接口就是规范，定义的是一组规则，体现了现实世界中“如果你是...则必须能...”的思想。如果你是天使，则必须能飞。如果你是汽车，则必须能跑。

• 接口的本质是契约，就像我们人间的法律一样。制定好后大家都遵守。

• OO的精髓，是对对象的抽象，最能体现这一点的就是接口。为什么我们讨论设计模式都只针对具备了抽象能力的语言（比如c++、java、c#等)，就是因为设计模式所研究的，实际上就是如何合理的去抽象。

public interface Time {
    void day();
}
public interface User {
     void add();
     void delete();
     void update();
     void query();
}
public class True implements User,Time{
    @Override
    public void add() {}
?
    @Override
    public void delete() {}
?
    @Override
    public void update() {}
?
    @Override
    public void query() {}
?
    @Override
    public void day() {}
}

8.内部类

• 内部类就是在一个类的内部在定义一个类，比如，A类中定义一个B类，那么B类相对A类来说就称为内部类，而A类相对B类来说就是外部类了。

• 1.成员内部类

• 2.静态内部类

  • 带有static修饰符的

• 3.局部内部类

  • 方法里面的class

• 4.匿名内部类

  • 不用将实例保存到变量中

    • new Apple().eat();

public class Outer {
    
    private static int id = 10;
    
    public void out(){
        System.out.println("这是一个外部类");
    }
    
    public class in{
        public void ina(){
            System.out.println("这是一个内部类");
        }
?
        //获得外部类的私有属性
        public void getID(){
            System.out.println(id);
        }
    }
}

9.异常机制

什么是异常

• 实际工作中，遇到的情况不可能是非常完美的。比如:你写的某个模块，用户输入不一定符合你的要求、你的程序要打开某个文件，这个文件可能不存在或者文件格式不对，你要读取数拒库的数据，数据可能是空的等。我们的程序再跑着，内存或硬盘可能满了。等等。

• 软件程序在运行过程中，非常可能遇到刚刚提到的这些异常问题，我们叫异常，英文是:Exception，意思是例外。这些，例外情况，或者叫异常，怎么让我们写的程序做出合理的处理。而不至于程序崩溃。

• 异常指程序运行中出现的不期而至的各种状况,如:文件找不到、网络连接失败、非法参数等。

• 异常发生在程序运行期间,它影响了正常的程序执行流程。

简单分类

• 要理解Java异常处理是如何工作的，你需要掌握以下三种类型的异常:

• 检查性异常:最具代表的检查性异常是用户错误或问题引起的异常，这是程序员无法预见的。例如要打开一个不存在文件时，一个异常就发生了，这些异常在编译时不能被简单地忽略。

• 运行时异常:运行时异常是可能被程序员避免的异常。与检查性异常相反，运行时异常可以在编译时被忽略。

• 错误:错误不是异常，而是脱离程序员控制的问题。错误在代码中通常被忽略。例如，当栈溢出时，一个错误就发生了，它们在编译也检查不到的。

10.异常处理机制

• 抛出异常

• 捕获异常

• 异常处理五个关键字

  • try catch finally throw throws

public class Text {
    public static void main(String[] args) {
?
        try {
            new Text().test(11, 0);
        } catch (ArithmeticException e) {
            e.printStackTrace();
        } finally {
        }
    }
?
    public void test(int a, int b) throws ArithmeticException{
?
        if (b == 0) { //主动抛出异常,一般在方法中使用
?
            throw new ArithmeticException();
        }
        System.out.println(a / b);
    }
}
/*
int a = 1;
        int b = 0;
        try {
            new Text().a();
            System.out.println(a / b);
        }catch (Error e){ //捕获异常
            System.out.println("程序出现异常，变量b不能为0");
        }finally {  //处理善后工作
            System.out.println("finally");
        }
    }
    public void a(){
        b();
    }
    public void b(){
        a();
    }
 */

11.自定义异常

• 使用Java内置的异常类可以描述在编程时出现的大部分异常情况。除此之外，用户还可以自定义异常。用户自定义异常类，只需继承Exception类即可。

• 在程序中使用自定义异常类，大体可分为以下几个步骤: 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=" + detail +
                '}';
    }
}

public class Text {

    //可能会存在异常的方法
    static void test(int a) throws MyException {
        if (a > 10){
            throw new MyException(a);
        }
        System.out.println("OK");
    }

    public static void main(String[] args) {
        try {
            test(11);
        } catch (MyException e) {
            e.printStackTrace();
        }
    }

}

12.实际应用中的总结

• 处理运行时异常时，采用逻辑去合理规避同时辅助try-catch处理

• 在多重catch块后面，可以加一个catch (Exception)来处理可能会被遗漏的异常

• 对于不确定的代码，也可以加上try-catch，处理潜在的异常

• 尽量去处理异常，切忌只是简单地调用printStackTrace()去打印输出

• 具体如何处理异常，要根据不同的业务需求和异常类型去决定

• 尽量添加finally语句块去释放占用的资源