饮水思源，附上学习视频：

https://www.bilibili.com/video/BV12J41137hu

害，研究生要开学了，好好学习，为了以后的打工之路

面向对象 OOP

什么是面向对象

本质：以类的方式组织代码，以对象组织数据。

三大特性：封装、继承、多态

回顾方法的调用

1. 静态方法： 和类一起加载的
2. 非静态方法： 类实例化后，才会存在的

显示区别：

在Java中，都是值传递。

类与对象的创建

在Java项目中，应该只有一个main方法。

main中的内容如下：

    public static void main(String[] args) {//类：抽象的，需要实例化//类实例化会返回一个自己的对象！//student 对象就是一个Student类的具体实例Student xiaoming = new Student();Student xiaohong = new Student();xiaoming.name = "小明";xiaoming.age = 3;xiaohong.name = "小红";xiaohong.age = 5;System.out.println(xiaoming.name);System.out.println(xiaohong.age);}

Student类中的代码如下：

public class Student {//属性：字段String name;int age;//方法public void study(){System.out.println(this.name + "在学习");}
}

实例化对象—构造方法

构造器中的构造方法特点：

1. 必须和类名相同
2. 必须没有返回类型，也不能写void

使用new关键字的本质就是在调用构造器；就是初始化值

    //默认的构造器public Person(){}//有参构造：一旦定义了有参构造，无参就无序显示定义public Person(String name){this.name = name;}

封装

程序设计追求“高内聚，低耦合”
高内聚：类的内部数据操作细节自己完成，不允许外部干涉；
低耦合：尽量暴露少量的方法给外部使用。

属性私有，get / set

下图说明一个Studen类的私有属性和公有方法：

public class Student {private String name; //名字private int id; //学号private char sex;  //性别public String getName() {return name;}public int getId() {return id;}public char getSex() {return sex;}public void setName(String name) {this.name = name;}public void setId(int id) {this.id = id;}public void setSex(char sex) {this.sex = sex;}}

快捷键：alt + insert

继承

extends

extends 的意思是“扩展”。 子类是父类的扩展。
Java中，类只有单继承，没有多继承。

快捷键：ctrl +H ，可以显示目前类的继承情况。

在Java中，所有的类都默认 直接或者间接继承object类
Java中只有单继承，没有多继承。

super

super在Java中的用法，如下图所示：

public class Student extends Person{private String name = "Jenny";public void test(String name){System.out.println(name); //输出传入的name参数的值System.out.println(this.name); //输出 JennySystem.out.println(super.name); //输出父类的name值（name不能是private）}}

子类的无参构造，会调用父类的构造器。

super的注意点：

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

VS this：

1. 代表对象不同
   this ： 本身调用的这个对象
   super ： 代表父类对象的应用

前提：
this： 没有继承也可以使用
super ： 只能在继承条件下才可以使用

构造方法：
this() ; 是本类的构造
super() ; 是父类的构造

方法重写

override是重写

注意点：

1. 需要有继承关系，子类重写 父类的public 非静态方法；
2. 方法名 参数列表 必须相同；
3. 修饰符的范围可以扩大，就是说 父类的是protected 子类可以是public
4. 抛出的异常：范围可以被缩小，但是不能扩大。ClassNotFoundException --> Exception

重写：
子类的方法和父类必须一致，但是方法体不同。

快捷键：alt + insert 选择override

多态

动态编译：类型
多态存在的三个必要条件：

1. 继承
2. 重写
3. 父类引用指向子类对象：Parent p = new Child();

举一个子父亲类的故事：
子类：

 */
public class Student extends Person{public void eat(){System.out.println("student eat");}@Overridepublic void run() {System.out.println("son");}
}

父类：

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

main函数情况：

public class Application {public static void main(String[] args) {//一个对象的实际类型是确定的Student stu1 = new Student();//父类的引用指向子类之后。类型就不确定了Person s2 = new Student();Object o1 = new Student();//对象能执行的方法，主要看左边的类型，和右边的关系不大stu1.eat();s2.run(); //子类重写了父类的方法，就会执行子类的方法}
}

总结几点：

1. 父类的引用可以指向子类。（也就是 父类 = new 子类）
2. 当子类重写了父类的方法时，Person s2 = new Student（）； s2这个对象会调用子类的方法。
3. 但是，Person s2 = new Student（）； s2不能调用子类有父类没有的方法。也就是说：对象能够执行哪些方法，主要是看 声明时，对象左边的类型，和右边关系不大！
4. 多态是方法的多态。从子类可以强制转换为父类。
5. static方法是属于类的，不是属于实例，所以不能重写；
6. final不能重写，常量；
7. private是私有方法，不能重写。

instanceof 和类型转换

首先说明父子类关系：
Object > String
Object > Person > Student
Object > Person > Teacher

public class Application {public static void main(String[] args) {Object object = new Student();System.out.println(object instanceof Student);System.out.println(object instanceof Person);System.out.println(object instanceof Object);System.out.println(object instanceof Teacher);System.out.println(object instanceof String);}
}

instanceof ：
如果object 属于instanceof之后类型（例如Student 、Object、Person，则返回true；不属于 instanceof 之后的类型，则返回false；

static关键字详解

先上代码：

public class Student {private static int age; //静态变量private double score; //非静态变量public void run(){}public static void go(){}public static void main(String[] args) {Student s1 = new Student();System.out.println(Student.age);System.out.println(s1.age);System.out.println(s1.score);//run(); //非静态方法直接调用会报错go();}
}

解释这段代码：

1. Student 类中，有两个静态的（static） 的字段，一个是属性int age，一个是方法go()。 可以看到，当我们想要调用这两个字段时，可以直接:类名.属性，对于方法：直接调用go（）；
2. 但是，对于非静态的字段，就必须要先实例化，然后才能调用。

在我们的常识里，一个类在被new（创建）出来类名 实例名 = new 类名；之后，总是会先执行构造方法，但是请看下图：

public class Person {{System.out.println("匿名代码块");}static {System.out.println("静态代码块");}public Person(){System.out.println("构造方法");}public static void main(String[] args) {Person p1 = new Person();}}

输出的结果是：

总结：

1. 静态方法块内的代码，才是第一个执行的；只执行一次
2. 第二个执行的是匿名代码块
3. 然后是构造方法

抽象类

abstract 写在类之前，就是抽象类；写在方法前就是抽象方法。
例如：

public abstract class Person
public abstract void doSomething();

注意点：

1. 不能new这个抽象类
2. 抽象方法必须在抽象类中，抽象类中可以写抽象方法
3. 抽象类只能单继承，接口可以多继承

接口

接口就是规范，定义的是一组规则。
接口的本质是契约，面向接口的编程

创建一个interface文件：首先在文件夹右击选择new，选择Java Class

之前直接选择第一个 Class ，现在选择第二个 Interface

在Interface中，写入下方代码。可以看到 关键字public abstract都是灰色的，说明interface中默认所有的方法都是 puiblic abstract 类型的。可以省略。

public interface UserService {//接口中的所有定义其实都是抽象的 public abstract void run(String name); //void run();即可}

接口都需要实现类。接口的关键字是interface，实现类的类名后缀是impl

例如：

类UserServiceImpl 可以实现接口 UserService，但是需要重写接口 UserService中的所有方法。
如下图所示：

public class UserServiceImpl implements UserService{@Overridepublic void add(String name) {}@Overridepublic void delete(String name) {}@Overridepublic void edit(String name) {}@Overridepublic void search(String name) {}
}

利用接口可以实现多继承。

public class UserServiceImpl implements UserService,TimeService{//中间需要override UserService和TimeService中的所有方法
}

总结：

1. 接口就是约束，好的架构师就是要会写接口
2. 接口不能被实例化，因为接口不是类，没有构造方法
3. implements 可以实现多个接口
4. 必须重写接口中的方法
5. public abstract + 方法
6. public static final + 属性（一般来说，接口中不放属性）

内部类

内部类就是将一个类定义在一个类的内部：

public class Outer {private int id;public void out(){System.out.println("这是外部类的方法");}class Innner{public void in(){System.out.println("这是内部类的方法");}}}

不常用。就不总结了。

异常机制

异常的英文是：Exception

简单分类：

• 检查性异常
• 运行时异常
• 错误ERROR：与JVM相关

Java把异常当作对象来处理，java.lang.Throwable作为异常的超类。

Error

Error类对象由Java虚拟机生成并抛出，大多数与程序员无关。
Error通常是灾难性、致命的问题，java虚拟机（JVM）一般会选择终止进程。

Exception

程序应该从逻辑角度尽可能避免这类异常。
例如：数组下标越界、空指针异常、算术异常、丢失资源、找不到类等等

异常处理机制

五个关键字： try catch finally throw throws

public class Test {public static void main(String[] args) {int a = 1;int b = 0;try{ //try就是监控区域System.out.println(a/b);}catch (ArithmeticException e){System.out.println("程序出现异常，变量b不能为0");}finally{System.out.println("finally");}}}

总结：
try、catch 是必要的，finally是完成善后工作。

快捷键：可以快速生成 try catch finally

ctrl + alt + T