面向对象

• 类简介

就是模板，?来定义?类对象的?法和属性，?如?、学?、猫，万物都是有模板，都是可以定义为类。 (类名?字??写)

• 对象

类的实例化，?如 学?这个类实例化，就是 XX同学

# 如下
Student student = new Student();
Cat cat1 = new Cat();
new Persion();

• 方法

?法是语句的集合，在?起完成?个功能
?法包含于类或对象中，即普通?法或者类?法

• 继承

?类继承?类的特征和?为，使得?类对象具有?类的?法和属性
?类也叫基类，具有公共的?法和属性

格式，通过extends关键字
class ?类名称{
 
}

class ?类名称 extends ?类名称{
 
}

?类拥有?类的?private的属性和?法
?类可以???的?式实现?类的?法 override(重写，覆盖)
实现了代码的复?
重写从?类那?继承来的?法的，当调??法时候会优先调??类的?法（默认就近原则）

不?持多继承，?持多重继承，多重继承提?了耦合性，组合优于继承
所有的类都是继承于 java.lang.Object
final关键字
    修饰的类，则这个类不可以被继承
    修饰?法，则这个?法不允许被覆盖（重写）

• 多态

同?个?为具有多个不同表现形式的能?
优点：减少耦合、灵活可拓展
?般是继承类或者重写?法实现

• 抽象

关键词abstract声明的类叫作抽象类，abstract声明的?法叫抽象?法
?个类?包含了?个或多个抽象?法，类就必须指定成抽象类
抽象?法属于?种特殊?法，只含有?个声明，没有?法体

当?类的某些?法不确定时，可以?abstract关键字来修饰该?法，即抽象?法，?abstract来修饰该类，即抽象类
抽象类将事物的共性的东?提取出来，由?类继承去实现，代码易扩展、易维护

# 格式
//抽象类
abstract class 类名{
}

//抽象?法，不能有?法主体
abstract 返回类型 ?法名();

# 如下
public abstract class Vehicle {
   // 抽象方法
   public abstract void run();
   // 普通方法
   public void stop(){
       System.out.println("停在路上");
   } 
}

class Bicycle extends Vehicle{
   // 重写抽象方法
   @Override
   public void run() {
       System.out.println("??驱动");
   } 
}

class Automobile extends Vehicle{
   // 重写抽象方法
   @Override
   public void run() {
       System.out.println("汽油驱动");
   } 
}

• 抽象类的特点

抽象类不能被实例化，因为抽象类中?法未具体化，这是?种不完整的类，所以不能直接实例化，编译?法通过
抽象类中不?定包含抽象?法，但是有抽象?法的类必定是抽象类
如果?个抽象类中可以没有抽象?法，这样做的?的是为了此类不能被实例化。
抽象类的?类必须给出抽象类中的抽象?法的具体实现，否则?类也是抽象类，需要?abstract声明
抽象类不能使?final关键字修饰，因为final修饰的类是?法被继承

• 抽象?法的特点

抽象类中的抽象?法只是声明，不包含?法体
抽象?法不能?private修饰，因为抽象?法必须被?类实现（覆写），?private权限对于?类来 说是不能访问的
?个类继承了?个抽象类，那么它必须全部覆写抽象类中的抽象?法，当然也可以不全部覆写，如果 不覆写全部抽象?法则这个?类也必须是抽象类

构造?法，类?法（即static 修饰的?法）不能声明为抽象?法

• 接口

是抽象?法的集合，接?通常以interface来声明，?个类通过继承接?的?式，从?来继承接?的抽象?法

interface 名称 [extends 其他的接?名] {
   // 声明变量
   // 抽象?法
   int getMoney();
}

• 接?的特点

 * 接?的?法都是抽象?法，默认都是 public abstract，其他修饰符都会报错
 * 接?中可以含有变量，但是接?中的变量会被隐式的指定为 **public static final**
 * 类描述对象的属性和?法，?接?则包含类要实现的?法
 * 接??法被实例化，需要被实现才?
 * ?个实现接?的类，必须实现接?内所描述的所有?法，否则就必须声明为抽象类

• 接?和类的区别

 * 接?没有构造函数
 * 接??可以有静态?法和?法体
 * 接?中所有的?法必须是抽象?法（JDK8之后就不是）
 * 接?不是被类继承了，?是要被类实现
 * 接??持多继承, 类不?持多个类继承

• 接?的实现implements

当类实现接?的时候，类要实现接?中所有的?法，不然类必须声明为抽象的类，使?implements关键字实现所有接?

class 类名 implements 接?名称[其他接?名称, 其他接?名称]{
   //要实现的?法
}

• 接口的继承

?个类只能继承?个类，但是能实现多个接?
接?能继承另?个接?，接?的继承使?extends关键字，和类继承?样

• 接口在JDK8中的新特性

interface中可以有static?法，但必须有?法实现体，该?法只属于该接?，接?名直接调?该?法
接?中新增default关键字修饰的?法，default?法只能定义在接?中，可以在?类或?接?中被重写，default定义的?法必须有?法体
?接?的default?法如果在?接?或?类被重写，那么?接?实现对象、?类对象，调?该?法，以重写为准
本类、接?如果没有重写?类（即接?）的default?法，则在调?default?法时，使??类定义的default?法逻辑

• 构造函数

?种特殊的?法
创建对象时?来初始化对象，每次使?new 创建对象的时候，就会使?构造函数
与类具有相同的名称，但是没有返回值
Java会?动为每个类提供?个默认构造函数
如果??定义了构造函数，就不再使?默认构造函数，如果没有显示的写出默认构造函数，则会消失

如果构造函数之间互相调?，务必写在?法第??

• 构造函数类型

默认构造函数
    public 类名(){
    }

?参构造函数
    public 类名(){
    //写?定义的语句
    }

有参构造函数
    public 类名(参数类型1 参数名1，参数类型2 参数名2...){
    //?定义?法体
    }

• 构造函数修饰符

public ?的最多，?来创建对象
private 私有化构造函数，不给外部创建对象，?如?具类，或者单例设计模式
default 默认的话，只能在当前包??使?new 创建对象，?乎不?

• 封装

# 封装是把过程和数据包围起来，对数据的访问只能通过已定义的接?即?法
# 在java中通过关键字private，protected和public实现封装
# 封装把对象的所有组成部分组合在?起，封装定义程序如何引?对象的数据，封装实际上使??法将类的数据隐藏起来，控制?户对类的修改和访问数据的程度。 适当的封装可以让代码更容易理解和维护，也加强了代码的安全性
# 类封装
# ?法封装

• overload（重载，过载）

在?个类??，?法名字相同，?参数不同，和返回类型?关

• override（重写，覆盖）

# ?类对?类的允许访问的?法的实现过程进?重新编写, 返回值和形参都不能改变；返回值类型，?法名，参数类型以及个数
# ?类能够根据需要实现?类的?法

注意点：
    返回值和形参都不能改变
    ?类的成员?法只能被它的?类重写
    final 和 static的?法不能被重写
    构造?法不能被重写
    访问权限不能??类中被重写的?法的访问权限更低

• 重写与重载的区别

override是在不同类之间的?为，overload是在同?个类中的?为

• this关键字

# 当?个对象创建后，JVM会给这个对象分配?个引??身的指针，这个指针的名字就是 this
# 只能?于?静态?法体内，静态?法和代码块不能出现this
# this就是指向当前对象本身

# 使用场景
this(参数类型1 参数名，...) 表示当前类对应的构造函数
?法形参和对象的属性重名，?this来区分

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

• super关键字

?个引?变量，?于引??类对象
?类和?类都具有相同的命名?法，要调??类?法时使?
?类和?类都具有相同的命名属性，要调??类中的属性时使?
super也是?类的构造函数，格式 super(参数)
注意点: 调?super() 必须是类构造函数中的第?条语句，否则编译不通过

• super注意点

每个?类构造?法的第?条语句，都是隐含地调?super()，如果?类没有这种形式的构造函数，那么在编译的时候就会报错

# 如下父类中编写无参构造器
public class Father {
   public Father(){
       System.out.println("father ?参构造函数");
   }
}
# 子类重写父类时，构造器中会使用super方法调用父类的无参构造器
public class Children extends Father{
   public Children(){
       //默认存在，写和不写都?
       super();
       System.out.println("Child?参构造函数");
   }
}

this()和super()都指的是对象，均不可以在static环境中使?包括：static变量,static?法，static语句块

• 构造函数 super和this：

this 和super在构造函数中只能有?个，且都必须是构造函数当中的第??
当?类的构造函数是?参构造函数时，在?类的构造函数中，不?显式super()去调??类的构造函数,
当?类的构造函数是有参构造函数时，如果?类的构造函数中不写super()进?调??类的构造函数，编译器会报错

• java继承后类的初始化顺序

# 父类
public class Father {
   // 静态代码块
   static {
       System.out.println("?类静态代码块");
   }
   // 构造器
   public Father(){
       System.out.println("father ?参构造函数");
   }
   // 有参构造器
   public Father(int age){
       System.out.println("father 有参构造函数");
   }
   // 普通方法
   public void sleep(){
       System.out.println("father sleep?法");
   }
}

# 子类继承父类
public class Children extends Father{
   static {
       System.out.println("Child静态代码块");
   }
   public Children(){
       //super();
       System.out.println("Child?参构造函数");
       super.sleep();
   }
   public void sleep(){
       System.out.println("Child sleep?法");
   }
}

# main方法测试
public static void main(String[] args) {
   new Children().sleep();
}

# 静态代码块、?静态代码、?类/?类?参构造?法、?类/?类的?般?法

• InstanceOf 关键词

是Java的?个?元操作符（运算符）,也是Java的保留关键字
判断?个类是否实现了某个接?，或者判断?个实例对象是否属于?个类

# 如下：如果该object 是该class的?个实例，那么返回true。如果该object 不是该class的?个实例，或者object是null，则返回false
boolean result = object instanceof class

# 如下：对象类型强制转换前的判断
Person p1 = new Student();
//判断对象p是否为Student类的实例
if(1p instanceof Student)
{
   //向下转型
   Student s = (Student)p1;
}