封装继承多态

1.类(class)
格式：

public class ClassName {
    //成员变量
    //成员方法(方法不需要加static，其他相同)
}

使用：类名 对象名 = new 类名()；
注意：
a.由于class整个都是new出来的，所以成员变量在堆内存中，但是成员方法在堆中仅仅是地址值，用于向方法区中寻找方法。当然方法调用的时候需要在栈内存中。
b.对象类型可以作为方法参数和返回值
2.封装
private关键字：代表私有权限，也就是private后的成员变量和方法只能在本类中才能访问
格式：idea中可以帮助创建get set成员方法，set用于对变量赋值，get用于调用变量。

public class Student {
    private String name;
    private int age;
    public void setName(String n) {
        name = n;
    }
    public String getName() {
        return name;
    }
    public void setAge(int a) {
        age = a;
    }
    public int getAge() {
        return age;
    }
}

this关键字：用于在当前类中对自身的引用，this即代表对象本身。
构造方法:方法名与所在类名相同
注意：
若不提供构造方法，那么系统会给出无参构造方法。
若已经提供构造方法，那么系统不会再提供无参构造方法。
构造方法根据情况可以有好多重载。
标准参考如下：

public class ClassName{
    //成员变量
    //构造方法
    //无参构造方法【必须】
    //有参构造方法【建议】
    //成员方法
    //getXxx()
    //setXxx()
}

3.继承：对存在多个相同属性的类的整合
作用：可以对父类的方法进行拓展
格式：

class 父类 {
…
}
class 子类 extends 父类 {
…
}

特点：
a.子类对象可以使用父类对象中的成员变量和方法
b.调用时会先在子类中寻找方法，若未找到再到父类中寻找
重名：
变量重名：若子类成员变量与父类重名，那么该变量访问到的是子类中的变量
方法重名：又叫方法重写，声明不变，实现重新写
super关键字：类似this关键字，用来在子类中访问父类中的成员变量和方法
注意：
a.一个类只可能有一个继承一个父类，但是可以多层继承。
b.构造方法先执行父类的，再执行子类的
4.抽象：abstract
抽象类：在class之前加上abstract即变为抽象类
例子：public abstract class 类名 { }
抽象方法：在返回值之前加上abstract，且删除大括号即可
例子：public abstract 返回值 方法名();
特点：
子类对象若想使用抽象成员方法，必须对抽象方法进行重写，也就是去掉abstract，并将方法的实现写入大括号
注意：
a.抽象方法只能在抽象类中定义，但是抽象类仍可以定义普通成员方法
b.抽象类不能创建对象
c.抽象类的子类必须重写父类中的所有抽象方法(若子类也是抽象类，那么子类的子类中必须有一个要重写抽象方法)
5.接口：封装了抽象方法，默认方法和静态方法，简单来说就是一个内部全是方法的类
定义：

public interface 接口名称 {
  //抽象方法
  //默认方法
  //静态方法
  //私有方法
}

抽象方法：public abstract void method();
注意：在接口中，抽象方法的public abstract可以省略
默认方法：public default void method(){ 代码 }
可以理解为接口中的普通方法，可以写入代码实现，也不需要必须重写
静态方法：public static void method(){ 代码 }
通过接口名称直接调用，不可以通过实现类调用
私有方法：使用private关键字修饰，用来私有化接口中的默认方法和静态方法
多继承：接口可以通过extends关键字来继承父接口，如果与父接口中默认方法有重名，那么子接口需要重写一次
注意：
a.接口中无法定义成员变量，但是可以定义接口常量，用public static final关键词修饰
b.接口中没有构造方法，不能创建对象
c.接口中没有静态代码块
6.实现：对于接口中抽象方法的实现类，可以看作是接口的子类
格式：接口与类不同的一点是一个实现类可以实现多个接口

class 类名 [extends父类名] implements 接口名1,接口名2,接口名3...{
//重写接口中抽象方法【必须】
//重写接口中默认方法【不重名时可选】
}

注意：
a.当不同的接口中有重名的默认方法时，必须重写
b.当一个类既继承父类，又实现多个接口时，父类中的成员方法与接口中的默认方法重名，那么子类会执行父类中的成员方法
7.多态：同一种行为具有多种表现形式
体现：左父右子
父类名称 对象名 = new 子类对象；
接口名称 对象名 = new 实现类对象；
优点：多态的对象可以方便整合，并且修改的时候直接在父类中修改即可
缺点：多态的对象是父类类型，也就是说不使用子类的特殊方法和变量了
8.引用类型的转换
向上转型：多态写法
特点：向上转型了之后，子类的特有方法就不能调用了(可以通过向下转型还原)
向下转型：父类类型向子类类型向下转换的过程，类似变量类型中的强制类型转换
格式：子类名称 对象名 = (子类名称)父类对象；
注意：要向下转型的前提是该类型要与原本的类型要保持一致
instanceof检查：得到一个boolean值，判断对象能不能作为转换的类型
格式：变量名 instanceof 数据类型
例子：If (Animal instanceof Cat) { 代码 }
9.final关键字：表示最终的、不可变的

10.访问权限

使用建议：
成员变量用private，隐藏细节
构造方法使用public，方便创建对象
成员方法使用public，方便调用方法
default表示默认的，也就是普通的权限，比如普通变量和方法，default一般可以不写
11.内部类：一个事物内部还包含其他事物
成员内部类：
格式：

class 外部类 {
    class 内部类 {
    }
}

权限：内用外，随意；外用内，需要内部类对象；（你的就是我的，我的还是我的)
储存：在存储中，用$来标识内部类，如Body$Heart.class，表明该类的是内部类
使用：
间接方式：通过外部类中的成员函数使用内部类
直接方式：外部类名称.内部类名称 对象名 = new 外部类名称().new 内部类名称();
例子：Body.Heart heart = new Body().new Heart();
重名访问：通过 外部类名称.this.成员变量 访问外部类的内容
局部内部类：类在方法中，只有该方法中可以使用该类
注意：局部内部类不需要写修饰符
访问：如果想访问所在方法的局部变量，那么这个局部变量必须是【有效final的】
匿名内部类：创建对象时只能创建唯一一次，但是不需要再单独创建一个实现类了，简单来说就是把实现类简化了
例子：
接口名称 对象名 = new 接口名称() { @Override 代码 }
区分：
匿名内部类：在【创建对象】的时候，只能创建唯一一次，
如果希望多次创建对象，且内容一样，那么必须单独定义实现类
匿名对象：在【调用方法】的时候，只能使用唯一一次，
如果希望同一个对象调用多次方法，那么必须创建对象变量
12.泛型：可以在类或方法中预支地使用未知的类型。当没有指定泛型时，默认类型为Object类型。
格式：修饰符 class 类名<代表泛型的变量> { }
例子：class ArrayList{ }
含有泛型的方法：修饰符 <代表泛型的变量> 返回值类型 方法名(参数) { }
例子：public void show(MVP mvp) { }
使用：调用方法时传递什么类型的参数确定什么类型的方法
格式2：修饰符 interface接口名<代表泛型的变量> { }
例子：public interface MyGenericInterface{ }
泛型的使用：
在定义实现类的时候就确定泛型：
public class MyImp1 implements MyGenericInterface { }
始终保留泛型直到创建对象
public class MyImp2 implements MyGenericInterface { }
泛型的通配符：在使用泛型类或者接口的时候，如果不确定数据类型，可以使用?来代替。
例子：public static void getElement(Collection<?> coll) { }
注意：定义的时候不能用，只能在参数传递的时候用。但是一旦使用了通配符之后，只能使用Object类中的共性方法，集合元素自身方法不能使用
受限泛型：
// 泛型的上限：此时的泛型?，必须是Number类型或者Number类型的子类
public static void getElement1(Collection<? extends Number> coll){}
// 泛型的下限：此时的泛型?，必须是Number类型或者Number类型的父类
public static void getElement2(Collection<? super Number> coll){}
注意区分：
泛型是需要在创建变量和方法的时候使用，而泛型的通配符是在传递参数的时候使用