一、封装

封装 ：    
		a.private -> 被private 修饰的成员只能在本类中使用，在别的类中无法使用。
        b.注意：
            将一个代码放到一个方法中也是封装的体现
            一个成员别private修饰，也是封装的体现，private更具备代表性
        c.private的使用
            修饰成员变量：private 数据类型 变量名
            修饰方法：将public改成private，其他都一样。
		* set方法：为属性赋值
        * get方法：获取属性值
		
javabean快速生成快捷键：
	alt + insert 选择constructor

标准的JavaBean：
        * 1.类必须是公共的具体的
        * 2.必须有私有属性
        * 3.必须有构造方法（无参，有参）
        * 4.必须有get/set方法

static静态关键字

static 一个静态关键字
    使用：
        1.修饰一个成员变量
            static 数据类型 变量名
        2.修饰一个方法
            修饰符 static 返回值类型 方法名（形参）{方法体；return 结果}
        3.调用静态成员：
            类名直接调用（不用new对象）因为静态成员属于类成员不属于对象成员
        4.静态成员特点
            a.静态成员属于类成员不属于对象成员（非静态成员属于对象成员）
            b.静态成员会随着类的加载而加载
            c.静态成员优先于非静态成员存在在内存中
            d.凡是根据静态成员所在的类创建的对象，都可以共享这个静态成员

可变参数

//可变参数
//格式 数据类型...变量名
//可变参数的本质是一个数组
//参数不能连续写多个可变参数
//可变参数和参数一起使用要把可变参数放在最后
public class Demo01Var {
    public static void main(String[] args) {
        sum(1,2,78,89,14);
    }
    public  static void sum(int...arr){
        int sum = 0;
        for (int i1 = 0; i1 < arr.length; i1++) {
            sum+=arr[i1];
        }
        System.out.println("sum = " + sum);
    }
    //参数不能连续写多个可变参数
    //可变参数和参数一起使用要把可变参数放在最后
    public static void sum2(int i, int...arr1){

    }
}

二、继承

父类和子类

属性看左边，方法看右边
    父类 name =。。。//name是父类里面的name
      子类 name =。。。//name是子类里面的name

继承中成员变量访问特点：看等号左边是谁
继承中成员方法访问特点：看等号右边是谁

方法的重写

概述：子类中有一个方法名以及参数列表相同的方法
前提：继承
检测，在子类重写的方法上写一个@Override，不报错就是重写。
注意：子类重写父类方法之后，访问权限要大于等于父类权限。
public -> protected->默认->private 权限从大到小
子类重写父类方法，方法名和参数列表要一样
私有方法，构造方法，静态方法不能被重写。
子类重写父类方法，返回值类型应该是父类方法返回值子类类型

接口

接口的定义和使用

接口：是一个引用数据类型
关键字:
    1.interface 接口
    public interface 接口名{}
    2.implements 实现
     public class 实现类类名 implements 接口名{}
		(实现类类名命名一般在后面加一个Impl,用于区分这是实现类而不是普通类比如 InterImpl)
使用:
1.实现类实现接口
2.重写接口中的抽象方法
3.创建实现类对象(接口不能直接new对象)
4.调用重写的方法
接口中可定义的成员:
抽象方法:public abstract
        定义格式:public abstract 返回值类型 方法名(形参);
        注意:不写public abstract 默认也有
        使用:1.定义实现类,实现接口
            2.重写抽象方法
            3.创建实现类的对象,调用重写的方法
默认方法:
        格式:public default 返回值类型 方法名(形参){
            方法体
            return 结果 }
        使用:
        1.定义实现类,实现接口
        2.默认方法可重写,可不重写
		(但是当一个类实现多个接口时，如果多个接口中默认方法有重名的，且参数一样的，必须重写一次)
        3.创建实现类对象,调用默认方法
静态方法:
        格式:public static 返回值类型 方法名(形参){
            方法体
             return 结果 }
        使用:接口名直接调用
抽象方式有点兴师动众:接口里面定义抽象,后面都要强制重写
默认方法和静态方法:可以临时小功能使用

成员变量

格式:
    public static final 数据类型 变量名 = 值
相关知识点:final
    final 代表最终值,被它修饰的变量,不能二次赋值,可视为常量.
特点:不写 public static final 默认也有
使用:接口名直接调用
注意：
	1.被 static final 修饰的变量要手动赋值
	2.习惯上将 static final 修饰的变量大写，这是开发是默认的习惯

接口的特点

1.一个接口可以多继承 ->一个接口可以继承多个接口（一个子类不能继承多个父类）
public interface InterfaceA extends InterfaceB，IneterfaceC{}
2.接口可以多实现 ->一个实现类可以实现一个或者多个接口
public class Interface implements InterfaceA,IterfaceB,InterfaceC{}
3.一个子类可以继承一个父类的同时实现一个或者多个接口
public class zi extends Fu implements InterfaceA,InterfaceB,InterfaceC{}
4.注意:
	无论是继承还是接口,父类或者接口里面存在抽象方法,子类或者实现类都要重写.
	  (如果一个类实现多个接口时,其中接口中的抽象方法有重名且参数一样,那么这个重复的只需要重写一次就可 )

接口与抽象类的区别

相同点：
	1.都位于继承体系的顶端，用于被其他类实现或者继承
	2.都不能new
	3.都包含抽象方法，其子类或者实现类必须重写这些抽象方法
不同点：
	1.抽象类一般作为父类使用，可以有成员变量，构造，成员方法，抽象方法等（抽象类：成员变量，构造，方法）
	2.接口成员单一，一般抽取接口，抽取的都是方法，被视为功能的大合集。（接口：方法）
	3.类不能被多继承，但是接口可以多继承。