一.Static
1.static修饰成员变量
被static修饰的成员变量，也叫做类变量，与类一同加载，只加载一次，被当前类的所有对象共享，只有一个
可以通过类名.属性的方法调用，也可以使用对象.属性的方式调用
应用场景：例如统计构造方法创建的对象数量
2.static修饰成员方法
被static修饰的成员方法，也叫做类方法，可以通过类名.方法访问一般用作工具类
作用，提高了代码的复用性，不用创建对象调用方法，节省了内存
类方法在其类中可以直接用方法名调用，类方法中不能出现this关键字
3.静态代码块
作用：完成类的初始化
静态代码块
//类加载时，静态代码块自动加载，执行块中的语法，和类一样，代码块只加载一次
static
{
}
实例代码块
//结构
{
}
在调用构造方法创建对象时（new Object），实例代码块会在构造方法前同步输出,实例化一次，调用一次
4.单例模式
设计模式：针对一个问题的最优解
实现步骤
//饿汉单例，只能有一个类对象，在使用对象时，对象提前创建好了
1.私有化构造方法
2.定义一个类变量对象
3.创建一个类方法，返回当前的对象
public class classname
{
private static ClassName name=new ClassName();
private classname(){}
public static A geyObject()
{
return name;
}
}
//懒汉单例
1.私有构造方法
2.创建一个类变量用于存储对象
3.提供一个类方法，保证返回的是同一个对象
public class classname
{
private static ClassName name;
private classname(){}
public static A geyObject()
{
if(name==null)
{
name=new ClassName();
}
return name;
}
}
单例模式的好处：只有一个对象，节约内存，如任务管理器，有一个就足够了
二.继承
作用：提高代码的复用性
1.重写
将父类的方法在子类中重新定义，重写的方法必须和父类的方法同名同参
私有方法和静态方法不能被重写
2.在子类中访问类成员
当子类、父类、局部变量名称一致，遵循就近原则
也可以通过this.属性/方法关键字，调取当前类的属性通过super可以调用父类的属性
3.子类构造器
子类继承了父类后，子类调用构造方法时，同时也会调用父类的构造方法
三.多态
1.
多态是在继承或者实现情况下的一种现象：对象多态，行为多态
多态的前提
1.有继承或者实现
2.存在父类引用子类对象
3.存在方法的重写
//父类
public class People
{
public void function()
{
System.out.print("这是父类方法中的run")}
}
//子类对象1
public class Student extend People
{
@Override
public void function()
{
System.out.print("这是学生方法中的run")}
}
//子类对象2
public class Teacher extend People
{
@Override
public void function()
{
System.out.print("这是老师方法中的run")}
}
//测试
People p1=new Student(); //对象多态
p1.function() // 行为多态
People p2=new Teacher();
p2.function();
输出结果
这是学生方法中的run
这是老师方法中的run
多态的好处：
1.实现功能的解耦合
2.可以将父类作为参数，接收一切子类
坏处：
1.不能接收子类自有的方法
解决方法：对象类型强转
在执行强转的时候，需要辨别强转的类型是否是父类和子类的强转，子类间不能强转
类型判断
对象 instanceof 类名，判断当前对象得真实类型
2.Final、常量
//可修饰成员变量（静态成员、实例成员变量）局部变量
//被修饰得变量只能进行一次赋值
//如果是修饰引用数据的话，数据可以改变，但Final指向的地址不变
如：final int [] arr={11,22,33,44}
arr[1]=20;
常量：被static final修饰的成员变量
三.抽象类
1.定义
抽象类抽象方法：被abstrict修饰的方法或类，抽象类可以没有抽象方法，抽象方法不能有方法体，抽象类不能创建对象
特点
1.抽象类不一定有抽象方法，有抽象方法的一定是抽象类
2.抽象类不能实例化对象，只能被继承
3.一个类继承抽象类，必须重写完抽象类的全部抽象方法，否则这个类也必须定义成抽象类
4.类具有的成员（成员变量，成员方法，构造器），抽象类都可以有
抽象类的目的：更好的支持多态
//案例
父类
public abstract class Animal
{
private String name;
public abstract void cry();//抽象方法
public void getName()
{
return name;
}
public String setName(String name)
{
this.name=name
}
}
子类
public class Cat extends Animals
{
@Override
public void cry()
{
System.out.print(getName+"喵喵叫")
}
}
测试类
Animal animal=new Cat();
animal.setName("cat")
animal.cry();
抽象类的应用场景，父类知道子类的行为，但是每个子类的行为又有所不同，父类就将该行为定义为抽象方法，由子类各自实现重写，更还得支持多态
4.接口
作用
1.解决继承中只能继承一个父类的问题，一个类可以实现多个接口
2.一个接口可以被多个类实现，一个类可以实现多个接口
JDK8版本后，新增的接口定义方法
//默认方法，通过实现类进行调用
default void test1()
{
System.out.print("==默认方法==");
}
//私有方法，在默认方法中调用
private void test2()
{
System.out.print("==私有方法==");
}
//静态方法，接口类名.方法调用，jdk9之后才能用
static void test3()
{
System.out.print("==静态方法==");
}
接口之间可以实现多继承，即一个接口可以继承多个接口，实现类直接对继承多个接口的接口类进行实现即可，就能完成实现多个接口的目标
5.内部类
在一个类中定义一个类
分类
1.成员内部类
//Outer外部类，Inner内部类
`Outer out=new Outer().new Inner()` 创建内部内对象
2.静态内部类
3.局部内部类
4.匿名内部类
//格式
new 类或接口（参数值）
{
类体（一般是方法的重写）
}
特点：匿名内部类本质是一个子类，会立即创建一个子类对象，一般作为方法的参数被调用
6.枚举
一般用作信息的分类
//枚举类
public enum Constant
{
BOY,GIRL
}
//信息分类的方法
public static void check(Constant sex)
{
switch(sex)
{
case BOY:
System.out.print("男");
break;
case GIRL:
System.out.print("女");
break;
}
}
//main方法
check(Constant.BOY);
#这样的写法可以规范枚举过程，只能传入规定的枚举值
7.泛型
定义类、接口、方法时，同时申明了一个或多个类型变量（如<Student>），称为泛型类，泛型接口，泛型方法，他们统称为泛型
#泛型类
修饰符 class 类名<类型变量，类型变量>
{
}
例如
public class A<R,E>
{}
A <Cat,String>a =new A<>()
//在调用a对象的方法时，第一个参数只能是Cat,第二个参数只能是String
#泛型接口
//定义一个泛型接口，根据类不同，实现接口的不同方法
public interface Data<T>
{
void add(T t);
ArrayList<T> getByName(String name);
}
//泛型接口中也可以有，Data<T extends Cat>,即泛型对象是Cat的子类或者Cat自己
//泛型接口的实现类
public class StudentData Implements Data<Student> //表示泛型接口中的类为Student对象
{
}
#泛型方法 ！！！！！！！重点
public static <T> T test(T t) //<T>就表示这是一个泛型方法，<T> T中的T表示返回值为泛型
{}
//泛型方法的参数限定,下列对泛型进行限定，输入的泛型只能是car或者car的子类
public static <T extends Car> void go(ArrayList<T> cars)
{
}
#在使用系统自己的泛型，非自定义泛型时，如ArrayList<E>,可以这样限定泛型方法
public static void go(ArrayList<? extends Car>)
{
}
//?表示通配符，即所有Car本身以及所有的子类
泛型只能接收类对象，不能传基本数据
ArrayList<Integer> a=new ArrayList<>() ✔
ArrayList<int> a=new ArrayList<>() x
