回看java基础，第四天

1、构造器

构造器名字和类名相同，没有返回值。
1)、无参构造器
2)、有参构造器

public class Demo01 {

    String name;

    //实例化初始值
    //1、使用new关键字，本质是在调用构造器
    //2、初始化值
    //无参构造  显示构造器
    public Demo01() {
    }

    //有参构造：一旦定义了有参数构造，无参就必须显示定义
    public Demo01(String name) {
        this.name = name;
    }
}

2、封装

1)、提高程序安全性，保护数据
2)、隐藏代码细节
3)、统一接口
4)、提高系统的可维护性

3、继承 extends

子类继承父类，子类拥有父类的全部的方法（修饰符为public）。
私有的无法被继承。

4、super、this

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

this：代表本身调用者这个对象；没有继承也可以使用；this()调用本类的构造；
super：代表父类对象的应用；只能在继承条件才能使用；super()调用的父类的构造；

5、重写

1、必须要继承关系，子类重新父类的方法
2、方法名必须相同
3、参数列表必须相同
4、修饰符：范围可以扩大，不能缩小	public>protected>default>private;
5、抛出异常，异常范围，可以被缩小，不能被扩大

6、多态

//父类
public class Person {
}
//子类
public class Student extends Person {
}
//子类
public class Teacher extends Person {
}

public class Demo01 {

    public static void main(String[] args) {
        //Student 能调用的方法都是自己的或者父类的
        Student s1 = new Student();
        //Person 父类型，可以指向子类，但不能调用子类的方法
        Person s2 = new Student();
        Object s3 = new Student();
    }
}

多态：
	1、多态是方法的多态，属性没有多态
	2、父类和子类，有联系，类型转换异常ClassCastException
	3、存在条件：必须有继承；方法需要被重写，父类引用指向子类对象 Person s2 = new Student();

instanceof

Object>String
Object>Person>Student
Object>Person>Teacher

public static void main(String[] args) {
        Object object = new Student();
        System.out.println(object instanceof Student);//true
        System.out.println(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
    }

类型转换
低 ——>高，可自动转换：Person per = new Student();
高 ——>低，需强制转换：Student stu = (Student) per;
子类转换为父类，可能会丢失属性或方法

7、抽象类 abstract 只能单继承

1、不能new抽象类，只能靠子类去实现，约束。
2、抽象类中可以写普通方法
3、抽象的方法必须写在抽象类中

8、接口 interface

接口可以实现伪多继承，interface定义，implements实现。
约束和实现分离：面向接口编程
实现接口：implements

9、内部类

1、内部类

public class Out {
    private int id;

    public void out() {
        System.out.println("这是外部类的方法");
    }

    public class In {
        private int id;

        public void in() {
            System.out.println("这是内部类的方法");
        }
        //获得外部类的私有属性 私有方法
        public void getId() {
            System.out.println(id);
        }
    }
}

public static void main(String[] args) {
        Out out = new Out();
        out.out();
        //通过外部类来实例化内部类
        Out.In in = out.new In();
        in.in();
    }

2、静态内部类

public class Out {
    private int id;

    public void out() {
        System.out.println("这是外部类的方法");
    }

    public static class In {
        public void in() {
            System.out.println("这是内部类的方法");
        }
        //内部类为静态时，无法获取id
        /*public void getId() {
            System.out.println(id);
        }
        */
    }
}

public static void main(String[] args) {
        Out out = new Out();
        out.out();
        //通过外部类来实例化内部类
        Out.In in = out.new In();
        in.in();
    }

3、局部内部类

public class Out {
    private int id;

    public void out() {
        System.out.println("这是外部类的方法");
        //局部内部类
        class In{
        
        }
    }
}

4、匿名内部类
没有名字初始化，不用把实例保存到变量中

10、异常

1、检查性异常
2、运行时异常
3、错误ERROR

抛出异常
方法内
throw new Exception();
方法
throws Exception;

捕获异常
try {//try监控区域

    }catch (Exception e){//catch(想要捕获的异常类型)捕获异常
        e.getMessage();
    }finally {	//处理善后工作
        
    }

自定义异常

public class MyException extends Exception {

    //异常值id
    private int id;

    public MyException(int a) {
        this.id = a;
    }

    //打印异常信息
    @Override
    public String toString() {
        return "MyException{" + id + "}";
    }
}

参考来源：哔哩哔哩，遇见狂神说视频。

标签：java,子类,回看,Student,第四天,println,new,public,out
来源： https://blog.csdn.net/b_x9520/article/details/112321849