InputStream

• 所有与IO操作相关的代码都必须正确处理IOException，否则无法正常运行。
• 读取文本是字节或字符串。

import java.io.FileInputStream;
import java.io.IOException;
import java.io.InputStream;

public class InputStreamStudy {
    public static void readFile() throws IOException{
        try(InputStream inputStream = new FileInputStream("c://CodeProject//JavaStudy//src//Flag")){
            int n;
            while ((n = inputStream.read()) != -1){
                System.out.println((char) n);
            }
        }
    }

    public static void readFileBuffer() throws IOException{
        try(InputStream inputStream = new FileInputStream("c://CodeProject//JavaStudy//src//Flag")){
            byte[] buffer = new byte[1000];
            int n;
            while ((n = inputStream.read(buffer)) != -1){
                System.out.println("read " + n + " bytes");
            }
        }
    }

    public static String readFileAsString(InputStream inputStream) throws IOException{
        int n;
        StringBuilder stringBuilder = new StringBuilder();
        while ((n = inputStream.read()) != -1){
            stringBuilder.append((char) n);
        }
        return stringBuilder.toString();
    }

    public static void main(String[] args) throws IOException {
        InputStream inputStream = new FileInputStream("c://CodeProject//JavaStudy//src//Flag");
        for (;;){
            int n = inputStream.read();  // 反复读取
            if(n == -1){
                break;
            }
            System.out.println(n); // 打印的byte的值
        }
        inputStream.close();

//        如果代码出错，并不会回收输入流，可用try
        readFile();

//        一次读取一个字节不高效，因此可以使用缓冲
        readFileBuffer();

//        读取文本字符
        String string;
        try(InputStream input = new FileInputStream("c://CodeProject//JavaStudy//src//Flag")){
            string = readFileAsString(input);
        }
        System.out.println(string);

    }
}

OutputStream

• 文件写入，没看到追加

import java.io.FileOutputStream;
import java.io.IOException;
import java.io.OutputStream;

public class OutputStreamStudy {

    public static void main(String[] args) throws IOException{
        String fileName = "c:\\CodeProject\\JavaStudy\\src\\Flag";
        try(OutputStream outputStream = new FileOutputStream("c:\\CodeProject\\JavaStudy\\src\\Flag")){
            outputStream.write("Hello Pan3a".getBytes("UTF-8"));
        }
    }
}

Scanner

• 推荐hasNextLine方法，直接获取全部数据，hasNext无法获取空格，认为其是结束符。

import java.util.Scanner;

public class ScannerStudy {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);

        System.out.print("next方法接收:");
//      判断是否还有输入
        if(scanner.hasNext()){
            String stringOne = scanner.next();
            System.out.println("输入的数据为:" + stringOne);
        }
        scanner.close();

        Scanner scan = new Scanner(System.in);
        System.out.print("nextLine方式接收:");
        if(scan.hasNextLine()){
            String stringTwo = scan.nextLine();
            System.out.println("输入的数据为:" + stringTwo);
        }
        System.out.print("请输入数字:");
        int count = 0;
        double sum = 0;
        while (scan.hasNextDouble()){
            double number = scan.nextDouble();
            count += 1;
            sum += number;
        }
        System.out.println("一共" + Integer.toString(count) + "个数");
        System.out.println("和为" + sum);
        scan.close();
    }
}

异常处理

面向对象

方法

• 主要是结合访问控制符和参数传递来实现特定功能。

class Person{
    String[] name = {};

    public Person(String... names){
        for(String name:names){
            System.out.println("构造方法可变参数: " + name);
        }
        this.name = names;
    }

    public void getName(){
        for (String name:this.name) {
            System.out.print(name + "   ");
        }
    }

    public void setName(String[] names){
        for (String setName:names){
            System.out.println("数组类型参数: " + setName);
        }
        this.name = names;
    }
}
public class ObjectFunc {
    public static void main(String[] args) {
        String[] names = {"Pan3a","Forever404"};
//      构造方法实例化
        Person personOne = new Person(names);
//      数组参数
        personOne.setName(names);

//      参数传递 指向的是原变量地址   改变变量实质变量名不变地址为新地址---新对象
        String name = "Pan3a";
        Person personTwo = new Person(name);
        personTwo.getName();
        name = "Forever404";
        personTwo.getName();

//      参数传递 数组地址没改变 改变的是地址中存的值
        String[] color = {"RED","BLUE"};
        Person personThree = new Person(color);
        personThree.getName();
        color[0] = "GREEN";
        System.out.println();
        personThree.getName();
    }
}

构造方法

• 每个类都有构造方法，没有则Java编译器将会提供一个默认的构造方法。构造方法需与类同名，一个类可以有多个构造方法。
• 构造方法类似于Python的__init__(self)主要作用于类的初始化。

package com.pan3a.test;
public class ObjectConstruct {
    public static void main(String[] args) {
        Person personOne = new Person();
        System.out.println(personOne.getName());
        System.out.println(personOne.getAge());

        Person personTwo = new Person("Pan3a",20);
        System.out.println(personTwo.getName());
        System.out.println(personTwo.getAge());

        Person personThree = new Person("Forever404");
        System.out.println(personThree.getName());
        System.out.println(personThree.getAge());
    }
}

class Person{
    protected String name;
    protected int age;

//  无参数构造方法，会自动创建，默认的构造方法
    public Person(){

    }

//  重载此构造方法，实例化类时根据传递参数自动选择构造方法
    public Person(String name,int age){
        this.name = name;
        this.age = age;
    }

//  构造方法调用其他构造方法
    public Person(String name){
        this(name,18);
    }

    public String getName(){
        return this.name;
    }

    public int getAge(){
        return this.age;
    }
}

方法重载

• 方法名相同，参数不同，返回值相同。
• overload，重载，相当于重新写了一个方法，但是这些方法都不同，因为它们的参数都不一样。

package com.pan3a.hello;
public class ObjectOverload {
    public static void main(String[] args) {
        Person personOne = new Person();
        personOne.hello();
        personOne.hello("Pan3a");
        personOne.hello("Pan3a",16);
        personOne.hello("Pan3a",20);
    }
}

class Person{
    public void hello(){
        System.out.println("Hello World");
    }

    public void hello(String name){
        System.out.println("Hello " + name);
    }

    public void hello(String name,int age){
        if (age > 18){
            System.out.println("Hello " + name + ", you are an adult!");
        }else
            System.out.println("Hello " + name + ", you are a child!");
    }
}

继承

• 子类无法继承父类的构造方法
• 子类的构造方法必须与父类的构造方法类型一致   如：无参对应无参
• 子类的构造方法第一条语句必须是父类构造方法
• 只能单继承，除Object外没有关键字extends的类都是继承于Object
• Java15特性，sealed于permits修饰的类只能在指定的类继承
• Java继承还有向上转型和向下转型两种。

sealed class Color permits Red,Blue,Green{
    
}

package com.pan3a.extend.up;
public class ObjectExtendsUp {
    public static void main(String[] args) {
        //      向上转型 因为继承关系 Student->Person->Object  Student有Person的全部属性
        Person personOne = new Student();
        System.out.println(personOne.name);
        System.out.println(personOne.age);
    }
}

class Person{
    public String name = "Pan3a";
    public int age = 18;
}

class Student extends Person{

}

package com.pan3a.extend.up;
public class ObjectExtendsUp {
    public static void main(String[] args) {
        //        向下转型 也是由于继承关系 但父类无法转为子类 因为子类有父类没有的属性
        Person p1 = new Student();
        Person p2 = new Person();
//        Student s2 = (Student) p2;  这里会由于实例化的Person，但变量类型是Student，变量类型中有Person中没有的属性因此会失败
        if(p1 instanceof Student){
            Student s1 = (Student) p1;
        }
    }
}

class Person{
    public String name = "Pan3a";
    public int age = 18;
}

class Student extends Person{

}

package com.pan3a.extend;
public class ObjectExtends {
    public static void main(String[] args) {
//        Student studentPan3a = new Student("Pan3a",18,60);
        Student studentPan3a = new Student();
        System.out.println(studentPan3a.getAge());
        System.out.println(studentPan3a.getName());
        System.out.println(studentPan3a.getScore());
        studentPan3a.setScore(99);
        System.out.println(studentPan3a.getScore());
    }
}

class Person{
    protected String name;
    protected int age;

    public Person(String name,int age){
        this.name = name;
        this.age = age;
    }

    public Person() {

    }

    public void setName(String name){
        this.name = name;
    }

    public String getName() {
        return name;
    }

    public void setAge(int age){
        this.age = age;
    }

    public int getAge(){
        return age;
    }
}

class Student extends Person{
    private int score;

    public Student(String name,int age,int score){
//      子类构造方法必须先调用父类构造方法
        super(name,age);
        this.score = score;
    }

//  这里子类的构造方法必须与父类对应  如：无参对应无参
    public Student(){
        super();
    }

    public void setScore(int score){
        this.score = score;
//        System.out.println("Score has change:" + Integer.toString(score));
    }

    public int getScore(){
        return this.score;
    }
}


final class Animal{

}

/*
这里就无法继承Animal类，因为此类用了final关键字进行修饰
class Teacher extends Animal{

}*/

方法重写

• Overrie，都是同一个方法，类型参数都一样，只不过实现功能有所更改。

package com.pan3a.override;
public class ObjectOverride {
    public static void main(String[] args) {
        Student studentOne = new Student();
        studentOne.hello();
    }
}

class Person{
    public void hello(){
        System.out.println("Hello");
    }
}

class Student extends Person{
    @Override
    public void hello(){
        super.hello();
        System.out.println("Hello World!");
    }
}

多态

• 根据不同类自动执行不同的方法，动态调用。

package com.pan3a.polymorphism;
public class ObjectPolymorphism {
    public static void running(Person p){
        p.run();
    }

    public static void main(String[] args) {
        running(new Person());
        running(new Student());
    }
}

class Person{
    public void run(){
        System.out.println("Person run");
    }
}

class Student extends Person{
    @Override
    public void run(){
        System.out.println("Student run");
    }
}

• 具体例子，多态就会自动选择实例类型。

public class ObjectPolymorphismDemo{
    public static void main(String[] args){
//      一个有普通收入 工资收入 国家补贴的人计算税
        Income[] incomes = new Income[]{
                new Income(3000),
                new Salary(7500),
                new StateCouncilSpecialAllowance(15000)
        };
        System.out.println(totalTax(incomes));
    }

    public static double totalTax(Income... incomes){
        double total = 0;
        for (Income income:incomes){
            total += income.getTax();
        }
        return total;
    }
}

class Income{
    protected double income;

    public Income(double income){
        this.income = income;
    }

    public double getTax(){
        return income * 0.1;
    }
}
// 计算税收
class Salary extends Income{
    public Salary(double income){
        super(income);
    }

    @Override
    public double getTax() {
        if (income <= 5000){
            return 0;
        }
        return (income - 5000) * 0.2;
    }
}
// 国家补贴免税收
class StateCouncilSpecialAllowance extends Salary{
    public StateCouncilSpecialAllowance(double income){
        super(income);
    }

    @Override
    public double getTax(){
        return 0;
    }
}

抽象类

• 抽象类只能被继承，目的是让代码更规范，因为子类必须实现父类定义的方法，即覆写父类方法。
• 抽象方法，如果一个类中包含抽象方法，不能包含方法体。那么该类必须是抽象类。任何子类必须重写父类抽象方法，除非子类也是抽象类。

package com.pan3a.abstractStudy;
public class AbstractStudy {
    public static void main(String[] args) {
        Person personOne = new Student("pan3a",18);
        personOne.run();
        System.out.println(personOne.getName());
    }
}

abstract class Person{
    private String name;
    private int age;

    public Person(){

    }

    public Person(String name,int age){
         this.name = name;
         this.age = age;
    }

   public abstract void run();

    public String getName(){
        return name;
    }

}

class Student extends Person{
    private String name;
    private int age;

    public Student(){

    }

//  此处不能使用Override来检查，因为构造房啊不会被继承
    public Student(String name,int age){
        super(name,age);
    }

    @Override
    public void run(){
        System.out.println("Student run");
    }

    public void say(){
        System.out.println("Hello " + this.name);
    }

    @Override
    public String getName(){
        String name = super.getName();
        return name;
    }
}

接口

• 接口也可继承，可一个类实现多个接口
• 接口可以定义default方法。
• 接口默认的方法都是public abstract，这两个只是被省略了。

package com.pan3a.interfaceStudy;
public class ObjectInterface {
    public static void main(String[] args) {
        Student personOne = new Student("Pan3a");
        personOne.say();
        personOne.red();
        personOne.medium();
        personOne.printColor();
        System.out.println(personOne.getName());
    }
}

interface Person{
    void say();
    String getName();
}

interface Color{
    void red();
//    定义接口方法，可以直接被继承调用
    default void printColor(){
        System.out.println("this is interface default method");
    }
}
// 接口继承接口
interface Size extends Color{
    void medium();
}

// 一个类实现多个接口
class Student implements Person,Color,Size{
    private String name;

    public Student(String name){
        this.name = name;
    }

    @Override
    public void say(){
        System.out.println("Hello World!");
    }

    @Override
    public String getName(){
        return this.name;
    }

    @Override
    public void red(){
        System.out.println("this is hello method!");
    }

    @Override
    public void medium() {
        System.out.println("this is medium!");
    }
}

内部类

• 一：直接创建一个类定义在另一个类的内部
• 这里的访问必须实例化外部类再来请求，内部类可访问父类的私有属性。

package com.pan3a.Inner;
public class ObjectInner {
    public static void main(String[] args) {
        Person personOne = new Person("Pan3a");
        Person.Student student = personOne.new Student();
        student.info();
    }
}

class Person{
    private String name;

    public Person(String name){
        this.name = name;
    }

    class Student{

        void info(){
            System.out.println("Hello " + Person.this.name + " I am a Student!");
        }
    }
}

• 二：匿名类，不需要在内部定义一个类，直接实例化。

public class ObjectInnerAnonymous {
    public static void main(String[] args) {
        AnonymousDemo anonymousDemo = new AnonymousDemo("Pan3a");
    }
}

class Inner{
    public void display(){
        System.out.println("在 Inner 类内部。");
    }
}

class AnonymousDemo{
    private String name;

    public AnonymousDemo(String name){
        this.name = name;
        inner.display();
    }

    // 匿名类继承一个类
    Inner inner = new Inner(){
        @Override
        public void display(){
            System.out.println("在匿名类内部。");
        }
    };
}

• 静态内部类

枚举

• 枚举限制变量只能使用预先设定好的值，相当于常量。如四季的春夏秋冬。
• 通过name()获取常量定义的字符串，注意不要使用toString()，因为它可以被覆盖。
• ordinal()获取常量定义的顺序，类似于数组的顺序，但是并没有实质意义，因为更改枚举元素之后顺序会发生变化。
• enum的构造方法要声明为private，字段强烈建议声明为final，常用于switch语句中。
• enum中也可以编写构造方法，字段，方法。
• 常量普通设定方法

class Year{
    public static final String spring = "spring";
    public static final String summer = "summer";
    public static final String autumn = "autumn";
    public static final String winter = "winter";
}

• 注意Java版本在JDK8版本之前使用equals进行输入对比判断。也可也使用===进行判断。如果使用==比较，它比较的是两个引用类型的变量是否是同一个对象。因此，引用类型比较，要始终使用equals()方法，但enum类型可以例外。

class Year{
    public static final String spring = "spring";
    public static final String summer = "summer";
    public static final String autumn = "autumn";
    public static final String winter = "winter";
}
public class EnumStudy {
    public static void main(String[] args) {
       String day;
       Scanner scan = new Scanner(System.in);
       day = scan.nextLine();
       scan.close();
       if(day.equals(Year.spring) || day.equals(Year.autumn)){
           System.out.println("OK");
       }
    }
}

• 迭代枚举元素

enum Years{
    SPRING,SUMMER,AUTUMN,WINTER;
}
public class EnumStudy {
    public static void main(String[] args) {
        for (Years y: Years.values()){
            System.out.println(y);
        }
    }
}

• 结合switch

反射

• Java的反射，Java的反射是指程序在运行期可以拿到一个对象的所有信息。
• 创建一个类，后面用来进行测试使用，注意请将一下测试文件都放在一个包内。

package com.pan3a.reflection;

public class ReflectionMain {
}

class Person{
    private int age;
    private String name;
    public long id=9527;
    public long grade;
    protected float score;
    protected int rank;

    public Person(){
    }

    protected Person(long id){
        this(18,"Pan3a",id,9,9999,31);
    }

    private Person(int age){
        this(age,"Pan3a",9527,9,9999,30);
    }

    public Person(int age,String name,long id,long grade,float score,int rank){
        this.age = age;
        this.name = name;
        this.id = id;
        this.grade = grade;
        this.score = score;
        this.rank = rank;
    }

    public int getAge(){
        return age;
    }

    public void setAge(int age){
        this.age = age;
    }

    public String getName(){
        return name;
    }

    public void setName(String name){
        this.name = name;
    }

    public long getId(){
        return id;
    }

    public void setId(long id){
        this.id = id;
    }

    public long getGrade(){
        return grade;
    }

    public void setGrade(long grade){
        this.grade = grade;
    }

    public float getScore(){
        return score;
    }

    public void setScore(float score){
        this.score = score;
    }

    public int getRank(){
        return rank;
    }

    public void setRank(int rank){
        this.rank = rank;
    }

    private static void sayHello(){
        System.out.println("Hello World");
    }

    private void sayHello(String name){
        System.out.println("Hello " + name);
    }

    @Override
    public String toString(){
        final StringBuffer stringBuffer = new StringBuffer("Person{");
        stringBuffer.append("age=").append(age);
        stringBuffer.append(", name='").append(name).append('\'');
        stringBuffer.append(", id=").append(id);
        stringBuffer.append(", grade=").append(grade);
        stringBuffer.append(", score=").append(score);
        stringBuffer.append(", rank=").append(rank);
        stringBuffer.append('}');
        return stringBuffer.toString();
    }
}

class Teacher extends Person{
    private String role = "Teacher";

    public void sayHello(){
        System.out.println("Hello Teacher");
    }
}

class Student extends Teacher{
    private String role = "Student";

    @Override
    public void sayHello(){
        System.out.println("Hello Student");
    }
}

获取对象

• 对象的获取有三种方式分别是Class.forName(全类名),对象.getclass()，类名.class。
• 这里的三种方式虽然作用都一样，但是都有各自的缺点。
• class.forName需要知道类名的全路径。对象名.class需要存在已经实例化的对象。类名.class需要提前在编译前知道类名。
• 下面会发现这里的比较都是true，因此说这里返回的对象都是同一个，因此Person.class只加载了一次。
• 用instanceof不但匹配指定类型，还匹配指定类型的子类。而用==判断class实例可以精确地判断数据类型，但不能作子类型比较。

package com.pan3a.reflection;

public class ReflectionGetClass {
    public static void main(String[] args) throws Exception{
        com.pan3a.reflection.Student student = new com.pan3a.reflection.Student();
        com.pan3a.reflection.Teacher teacher = new com.pan3a.reflection.Teacher();
        com.pan3a.reflection.Person person = new com.pan3a.reflection.Person();

        if(student instanceof com.pan3a.reflection.Person){
            System.out.println("Student 是 Person 子类");
        }

//      Class.forName
        Class class1 = Class.forName("com.pan3a.reflection.Person");
        System.out.println("别名:" + class1.getSimpleName());
        System.out.println(class1);

//      类名.class
        Class class2 = com.pan3a.reflection.Person.class;
        System.out.println(class2);

//      对象.getClass()
        com.pan3a.reflection.Person person1 = new com.pan3a.reflection.Person();
        Class class3 = person1.getClass();
        System.out.println(class3);

        System.out.println(class1 == class2);
        System.out.println(class1 == class3);
    }
}

成员变量

• 获取成员变量需要知道一下四个方法，getField，getFields，getDeclaredField，getDeclaredFields。
• 还可获取成员变量属性的三个方法，getType，getModifiers，getName。分别是获取变量类型，修饰符，成员名。
• 他们分别是获取单个成员，和获取所有成员，获取单个成员（忽略修饰服限制，不包括父类），获取多个成员（忽略修饰服限制，不包括父类）。需注意的是使用后面两个是需使用setAccessible(true)来忽略编译时的安全检查。
• 这里牵扯到了反射实现构造方法，后面也再会讲到。

package com.pan3a.reflection;

import java.lang.reflect.Field;
import java.lang.reflect.Modifier;

public class ReflectionGetField {
    public static void main(String[] args) throws Exception{
        Class class1 = Class.forName("com.pan3a.reflection.Person");
        getFieldStudy(class1);
        getFieldsStudy(class1);
        getDeclaredFieldStudy(class1);
        getDeclaredFieldsStudy(class1);
        setFieldStudy(class1);
    }

    public static void getFieldStudy(Class class1) throws Exception{
        System.out.println("getField");
        Field fieldId = class1.getField("id");
        System.out.println(fieldId);
        Field fieldGrade = class1.getField("grade");
        System.out.println(fieldGrade);
        System.out.println();
//      该对象还有其他成员但是用此方法无法获取，因为他们不是用public修饰的
    }

    public static void getFieldsStudy(Class class1){
        System.out.println("getFields");
        Field[] fields = class1.getFields();
        for (Field field : fields){
            System.out.println(field);
        }
        System.out.println();
    }

    public static void getDeclaredFieldStudy(Class class1) throws Exception{
        System.out.println("getDeclaredField");
        Field fieldAge = class1.getDeclaredField("age");
        System.out.println(fieldAge);
        Field fieldName = class1.getDeclaredField("score");
        System.out.println(fieldName);
        System.out.println();
    }

    public static void getDeclaredFieldsStudy(Class class1) throws Exception{
        System.out.println("getDeclaredFields");
        Field[] fields = class1.getDeclaredFields();
        for(Field field:fields){
            System.out.println("成员名:" + field.getName() + "\t成员修饰符:" + field.getModifiers() + "\t成员类型:" + field.getType());
        }
        System.out.println();
    }

//  反射修改私有成员值
    public static void setFieldStudy(Class class1) throws Exception{
        System.out.println("反射获取,修改成员值");
        com.pan3a.reflection.Person person = new com.pan3a.reflection.Person();
        System.out.println("ID:" + person.getId());
//      反射获取成员变量值并且修改成员变量
        Field fieldAge = class1.getDeclaredField("id");
        fieldAge.setAccessible(true);
//      实例化对象为后面获取,修改成员做准备,这里后面还会讲到的构造方法
        Object object = class1.newInstance();
        System.out.println("ID:" + fieldAge.get(object));
        fieldAge.set(object,9999);
        System.out.println("ID:" + fieldAge.get(object));
    }
}

构造方法

• 平常正向操作都是new一个对象。通过反射调用构造方法有两种方式，分别是Person.class.newInstance()，(Person)constructor.newInstance()。两者区别就是前者无法调用含参的构造方法，后者可以。
• 实例化对象时，对于非public的任然需要constructor.setAccessible(true)。

package com.pan3a.reflection;

import java.lang.reflect.Constructor;

public class ReflectionConstructor {
    public static void main(String[] args) throws Exception{
        Class personClass = Class.forName("com.pan3a.reflection.Person");

        System.out.println("所有构造方法");
        Constructor[] constructors = personClass.getDeclaredConstructors();
        for (Constructor constructor:constructors){
            System.out.println(constructor);
        }
        System.out.println();



        System.out.println("public无参数构造方法");
//      默认当前类的无参数构造方法
        Constructor constructor1 = personClass.getConstructor();
        System.out.println(constructor1);

        System.out.println("protected带参数构造方法");
        Constructor constructor2 = personClass.getDeclaredConstructor(long.class);
        System.out.println(constructor2);

        System.out.println("private带参数构造方法");
        Constructor constructor3 = personClass.getDeclaredConstructor(int.class);
        System.out.println(constructor3 + "\n");



        System.out.println("public无参数构造方法创建对象");
        Object person1 = constructor1.newInstance();
        System.out.println(person1);

        System.out.println("protected带参数构造方法创建对象");
        constructor2.setAccessible(true);
        Object person2 = constructor2.newInstance(9528);
        System.out.println(person2);

        System.out.println("private带参数构造方法创建对象");
        constructor3.setAccessible(true);
        Object person3 = constructor3.newInstance(18);
        System.out.println(person3);

        System.out.println("Person.class.newInstance()");
        Class class1 = com.pan3a.reflection.Person.class;
        Object object = class1.newInstance();
        System.out.println(object);
    }
}

成员方法

• 获取成员方法如通获取成员变量类似，也有四个方法。getMethod，getMethods，getDeclaredMethod，getDeclaredMethods。
• 获取方法属性，getName，getReturnType，getParameterTypes，getModifiers。

package com.pan3a.reflection;

import java.lang.reflect.Method;

public class ReflectionMethod {
    public static void main(String[] args) throws Exception{
        Class personClass = Class.forName("com.pan3a.reflection.Person");
        getMethodStudy(personClass);
//        getMethodsStudy(personClass);
        getDeclaredMethodStudy(personClass);
//        getDeclaredMethodsStudy(personClass);
    }

    public static void getMethodStudy(Class personClass) throws Exception{
        System.out.println("getMethod获取单个非public方法");
        Object object = personClass.newInstance();
        Method method = personClass.getMethod("getId");
        System.out.println(method);
        long Id = (long) method.invoke(object);
        System.out.println("Id:" + Id);

//      多态，依旧根据传入的实例化对象为准，如果没有则向父类寻找
        Class teacherClass = Class.forName("com.pan3a.reflection.Teacher");
        Method method1 = teacherClass.getMethod("sayHello");
        method1.invoke(new com.pan3a.reflection.Student());
    }

    public static void getMethodsStudy(Class personClass) throws Exception{
        System.out.println("getMethods获取所有非public方法");
        Method[] methods = personClass.getMethods();
        for (Method method:methods){
            System.out.println(method);
        }
    }

    public static void getDeclaredMethodStudy(Class personClass) throws Exception{
        System.out.println("getDeclaredMethod单个方法不限制修饰符");
        Object object = personClass.newInstance();
        Method method = personClass.getDeclaredMethod("sayHello",String.class);
        System.out.println(method);
        method.setAccessible(true);
        method.invoke(object,"Pan3a");

//      由于这里和方法为静态方法，因此object为null
        Method method1 = personClass.getDeclaredMethod("sayHello");
        method1.setAccessible(true);
        method1.invoke(null);
    }

    public static void getDeclaredMethodsStudy(Class personClass) throws Exception{
        System.out.println("获取所有方法");
        Method[] methods = personClass.getDeclaredMethods();
        for(Method method:methods){
            System.out.println("方法名:" + method.getName() + "\t方法返回值类型:" + method.getReturnType() + "\t方法参数类型:" + method.getParameterTypes() + "\t方法修饰符:" + method.getModifiers());
        }
    }
}

继承关系

• getSuperclass()，获取父类类型，getInterfaces()获取当前类实现的所有接口。

package com.pan3a.reflection;

public class ReflectionSuper {
    public static void main(String[] args) throws Exception{
        superClass();
        interfaceReflection();
    }

    public static void superClass() throws Exception{
        Class studentClass = Class.forName("com.pan3a.reflection.Student");
        Class teacherClass = studentClass.getSuperclass();
        Class personClass = teacherClass.getSuperclass();
        Class objectClass = personClass.getSuperclass();
        Class objectSuperClass = objectClass.getSuperclass();
        System.out.println(studentClass);
        System.out.println(teacherClass);
        System.out.println(personClass);
        System.out.println(objectClass);
//      综合可看出除了Object类外，如果类没有继承，那么默认继承Object。
        System.out.println(objectSuperClass);
    }

    public static void interfaceReflection() throws Exception{
        Class integer = Integer.class;
        Class[] integerInterfaces = integer.getInterfaces();
        for (Class integerInterface:integerInterfaces){
            System.out.println(integerInterface);
        }
    }
}

动态代理

• 平常实现接口方式。

package com.pan3a.reflection;

public class ReflectionDynamicProxy {
    public static void main(String[] args) {
        HelloWorld helloWorld = new HelloWorld();
        helloWorld.morning("Pan3a");
    }
}

interface Hello{
    void morning(String name);
}

class HelloWorld implements Hello{
    public void morning(String name){
        System.out.println("Good morning " + name);
    }
}

• 动态代理实现方法

package com.pan3a.reflection;

import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;

public class ReflectionDynamicProxy {
    public static void main(String[] args) {
        InvocationHandler invocationHandler = new InvocationHandler() {
            @Override
            public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
                System.out.println(method);
                if(method.getName().equals("morning")){
                    System.out.println("Good morning," + args[0]);
                }
                return null;
            }
        };
        Hello hello = (Hello) Proxy.newProxyInstance(
                Hello.class.getClassLoader(),
                new Class[] {Hello.class},
                invocationHandler);
        hello.morning("Pan3a");
    }
}

interface Hello{
    void morning(String name);
}

泛型

• 泛型就是定义一种模板

使用泛型

• 泛型类型实际上就是Object
• 使用泛型时就是把替换成需要的class类型

package com.pan3a.generics;

import java.util.Arrays;

public class GenericsInterface {
    public static void main(String[] args) {
        Person[] person = new Person[]{
                new Person("Pan3a",18),
                new Person("Forever404",20),
        };
        Arrays.sort(person);
        System.out.printf(Arrays.toString(person));
    }
}

class Person implements Comparable{
    String name;
    int score;

    Person(String name, int score){
        this.name = name;
        this.score = score;
    }

    public int compareTo(Person other){
        return this.name.compareTo(other.name);
    }

    public String toString(){
        return this.name + "," + this.score;
    }
}

编写泛型

public class GenericsEditor {
    public static void main(String[] args) {

    }
}
// 多泛型 class Pair
class Pair{
    private T first;
    private T last;

    public Pair(T first, T last){
        this.first = first;
        this.last = last;
    }

    public T getFirst(){
        return first;
    }

    public T getLast(){
        return last;
    }

//    静态方法使用泛型
    public static  Pair create(K first, K last){
        return new Pair(first,last);
    }
}

擦拭法

• 泛型实现方式是擦拭法（Type Erasure）。
• Java的泛型是由编译器在编译时实行的，编译器内部永远把所有类型T视为Object处理，但是，在需要转型的时候，编译器会根据T的类型自动为我们实行安全地强制转型。
• 局限一，不能是基本类型，例如int，因为实际类型是Object，Object类型无法持有基本类型。必须是如。
• 局限二，无法取得泛型的Class。
• 局限三，无法判断带泛型的类型
• 局限四不能实例化类型，因为编译器会把看成