面向对象 下

静态变量

静态变量
（1）静态变量的定义：是指有static修饰的成员变量
（2）静态变量的特点：
A：静态变量的值是所有对象共享的。
B：虽然可以，但不建议通过“对象.静态变量”的形式进行访问，
建议通过“类名.静态变量”的形式进行访问。
C：如果静态变量的可见性范围被限制了，提供get/set时，它的get/set也是静态的。
在set方法中，静态变量和局部变量（形参）重名了，使用“类名.静态变量”进行区分。
D：静态变量的值是存储在“方法区”中。

静态方法

静态方法
（1）静态方法的定义：是指有static修饰的方法。
（2）静态方法的特点：
A：静态方法中不允许直接使用本类的非静态成员
B：静态方法中也不允许直接使用this,super等关键字
C：静态方法的调用虽然可以用“对象.静态方法”的形式进行访问，
但是我们更推荐“类名.静态方法”的形式进行访问。
D：父类的静态方法可以被子类访问，但是不能被子类重写

静态代码块（不太重要）

静态代码块
（1）静态代码块的作用：为类的静态变量初始化
（2）静态代码块的执行特点
A：一个类的静态代码块只会执行一次
B：它是在类加载类初始化时执行，先于类对象的创建
（3）语法结构
【修饰符】 class 类名{
    static{
        静态代码块
    }
}

抽象类和抽象方法（*****)

1、什么是抽象类？
在class前面加abstract修饰的都是抽象类。

【其他修饰符】 abstract class 类名{

}

2、为什么要用抽象类？
（1）不希望你创建这个类的对象，希望你创建它子类的对象（少一点）
（2）当我们在声明某个父类时，其中某些方法不得不声明，但是又无法给出具体的实现，
即无法编写方法体代码，这个方法体代码通常由子类来实现，各个子类的实现不同，
这个时候需要把这样的方法声明为抽象方法，
Java中包含抽象方法的类必须是抽象类（更多的情况）。

3、抽象类的特点
（1）抽象类不能直接new对象，只能new它子类的对象
（2）抽象类中可以包含抽象方法，也可以不包含抽象方法。
但是反过来，包含抽象方法的类，必须是抽象类。
（3）抽象类是用来被继承的，子类继承抽象类时，必须重写抽象类的所有抽象方法，
否则子类也得是抽象类。

4、抽象类和非抽象类有什么区别？
抽象类不能直接new对象，非抽象类可以直接new对象，
抽象类中可以包含抽象方法，非抽象类中不可以包含抽象方法。

5、抽象类中有构造器吗？
一定有
它的构造器存在的意义是被子类调用的。

JUnit

说明：标准的单元测试编写方式，在实际项目中再讲。
今天，讲单元测试的JUnit的小工具只是把它当成一个代替main方法运行的小工具而已。

使用步骤：
（1）在当前模块中要引入JUnit的库
因为JUnit不是JRE核心类库的一部分，它是第三方的一个工具。
引入的方式很简单：
第一步：先写一个方法
第二步：在方法上面加一个@Test
第三步：@Test会报错，鼠标放到@Test上面，IDEA会提示我们需要引入JUnit的库（一堆class文件）
第四步：单击Add 'JUnit4' to classpath
第五步：下载，默认是下载到C盘用户目录下的.m2的仓库中
    （至于后期项目中如何依赖和下载，咱们学习Maven时再学习）

（2）凡是要独立运行的测试方法上面都可以加@Test

使用要求：
（1）自己写的类名，同一个包的所有类，包括当前类，不能命名为Test类。
（2）要使用@Test标记测试方法，
这个测试方法必须是public，void，()，非静态的
（3）@Test标记的测试方法所在类必须只有唯一的无参构造，并且也是public的。

接口（*****)

1、为什么要使用接口？
（1）Java的类只支持单继承
（2）Java的父子类是用于表示两个事物之间的is-a的关系，
但是很多类之间的关系不是is-a，它们是has-a的关系，
即它们有相同的方法。

接口的声明

2、如何声明接口呢？
【修饰符】 interface 接口名{
    //成员
}

interface就是声明接口的关键字，和原来的class用来声明类一样。
接口的修饰符，可以是public，缺省，其实还默认是abstract

接口的特点和成员要求

3、接口的特点
（1）接口不允许直接创建对象，因为它默认就是抽象的
（2）接口的成员是限制，和类的成员不一样
在JDK1.8之前，接口中只允许有：
    A：公共的静态的常量：public static final，而且这3个修饰符可以省略
    B：公共的抽象方法：public abstract，而且这2个修饰符也可以省略
    抽象方法没有方法体
在JDK1.8版本，接口新增了两类成员：
    C：公共的静态方法：public static，其中public可以省略，static不能省略
    D：公共的默认方法：public default，其中public可以省略，default不能省略
    静态方法和默认方法是有方法体。
在JDK1.9之后，接口又新增了一类成员：
    E：私有方法：private，但是private不允许省略

接口中没有构造器、代码块等等其他成员。
（3）类可以实现接口，关键字用implements。支持多实现，即一个类可以同时实现多个接口。
【修饰符】 class 类名 implements 接口们{

}
（4）一个实现类可以同时继承父类，又是父接口，但是要求继承在前实现在后。
【修饰符】 class 类名 extends 父类 implements 父接口们{

}

比喻：直接父类-->亲生父亲，它只有唯一的一个
      父接口们-->干爹们，它可以同时有多个

说明：
    子类和父类的变量可以构成多态引用，
    实现类和父接口的变量也同样构成多态引用。

（5）接口与接口之间也支持继承，而且是多继承。

总结：
    子类 extends 父类  单继承
    子接口 extends 父接口们 多继承
    实现类 implements 父接口们 多实现
（5）实现类在实现父接口时，要求实现父接口的所有抽象方法，
如果实现类不实现父接口的抽象方法，要么编译会报错，要么把实现类改为抽象类。

//实现接口的抽象方法的快捷键是Ctrl + I

内部类(***)

1、什么是内部类？
顾名思义：一个类里面的类称为内部类。
例如：
class Outer{   //相对的，它是外部类
    class Inner{ //内部类

    }
}

2、为什么要用内部类？
实现高内聚低耦合的开发原则。
好处：
（1）内部类，可以被限定在外部类中使用
（2）内部类和外部类可以互相访问对方的私有的成员

例如：
    设计一些数据结构，这些数据结构是单链表、双链表、二叉树等等。

匿名内部类(***)

1、首先，匿名内部类也是局部内部类，只是它没有名字。
2、语法格式：
（1）new 父类(){

}
（2）new 父类(实参列表){

}
（3）new 父接口(){

}

3、特殊
（1）这个内部类没有名字，所以必须在声明的同时，就创建它唯一的对象。
（2）这里new对象，指定了父类名或父接口名，指明了它是从哪个类别派生出来的。
匿名内部类又称为匿名子类或匿名实现类。
（3）因为匿名，所以这个类无法写构造器，只有默认的无参构造。
（4）因为没有class关键字等声明形式，所以匿名内部类没有任何修饰符。

枚举类（***）

枚举类是指一种特殊的类，这种类的对象只有有限的固定的几个常量对象。

2、什么情况会用枚举类呢？
例如：Month类，Week类等等，
他们的对象应该是固定的有限的几个。
Month类：12个对象
Week类:7个对象
Season（季节）类：4个对象

3、如何声明枚举类呢？
在JDK1.5之前：
(1)构造器私有化
(2)在枚举类的内部提前创建好几个固定的常量对象

在JDK1.5及其之后，简化了枚举类的声明：
【修饰符】 enum 枚举类{
    常量对象列表
}
【修饰符】 enum 枚举类{
    常量对象列表;
    其他成员列表
}
说明：如果常量对象列表后面没有其他成员，;可以省略。
      如果常量对象列表后面有其他成员，必须加;分隔。

4、enum声明的枚举类的特点
（1）构造器默认私有化
（2）不能用extends继承别的类，它的默认直接父类是java.lang.Enum类，
根父类仍然是Object。
（3）它也不能有子类。
（4）枚举类的所有对象必须在常量对象列表列出来，
如果常量对象只写名字，表示调用无参构造创建的对象，
如果常量对象名后面加(实参列表)，表示调用有参构造创建的对象
（5）枚举类中通常不声明其他的成员变量，当然也可以声明成员变量，
“建议”成员变量使用final声明。
因为枚举类的对象都是常量对象，通常属性也是不建议修改的。

包装类（***）

1、什么是包装类？
包装类是基本数据类型对应的引用数据类型。
基本数据类型和空类型   包装类
byte            <-> Byte
short           <-> Short
int             <-> Integer
long            <-> Long
float           <-> Float
double          <-> Double
char            <-> Character
boolean         <-> Boolean
void            <-> Void

2、为什么要有包装类呢？
Java是面向对象的语言，很多新特性语法，API都只针对对象设计的，
不支持基本数据类型，所以程序中用基本数据类型表示的地方，需要换成包装类的对象。

例如：后面要学习的泛型
     后面要学习的集合

3、装箱和拆箱
装箱：把基本数据类型的数据包装为包装类对象
拆箱：把包装类的对象拆解为基本数据类型的数据

在JDK1.5之前，装箱和拆箱需要手动进行，必须调用方法来完成。
在JDK1.5之后，编译器进行了升级，支持自动装箱和自动拆箱。
注意：自动装箱和自动拆箱只支持对应类型之前。

5、包装类对象特点
（1）包装类对象不可变
A：包装类对象可以共享，只是部分被缓存了
B：当形参是包装类型时，形参修改和实参无关

（2）部分包装类对象被缓存在常量池中
Byte,Short,Integer,Long：-128~127
Character：0-127
Boolean：true和false
Float和Double：没有缓存对象

    @Test
    public void test12(){
        Integer i1 = 1;
        Integer i2 = 1;
        System.out.println(i1 == i2);//比较地址值true
                                //i1和i2是指向缓存对象，同一个对象

        Integer i3 = 128;
        Integer i4 = 128;

        System.out.println(i3 == i4);//比较地址值false
                            //128超过缓存范围，用就new，它俩的地址不同
    }