Java Review SectionⅠ

Math类

abs()——绝对值
max(double a,double b)——a和b最大值
min(double a,double b)——a和b最小值
random()——产生0-1之间随机数

Date类

Date类用来表示日期和时间，该时间是一个长整形（long），精确到毫秒

boolean after(Date when)——判断日期是否在指定日期之后 true/false
boolean before(Date when)——判断日期是否在指定日期之前 true/false
SimpleDateFormat——指定日期格式，格式化日期
```
SimpleDateFormat simpleDateFormat=new SimpleDateFormat("yyyy-MM-dd");
System.out.println(simpleDateFormat.format(date));
```
年月日、时分秒
compareTo()——比较

类之间的关系

Object类是所有类的顶级父类
一个子类只能由一个直接父类，单一继承（extends）多次继承使用接口
涉及到金额用Bigdecimal，double慎用，易出现莫名其妙的错误
先调用父类的构造方法进行初始化，然后调用子类的构造方法进行初始化
多态——可以用子类对象赋值给父类对象
```
Product product=new Printer();
```

方法重写（override）——重写父类的方法

方法名及参数列表必须一致
返回值类型与父类保持一致，或是父类方法返回值类型的子类
子类方法声明的异常与父类保持一致，或是父类方法声明的异常的子类
父类的私有方法不能被子类重写，如果子类中定义了与父类重名的私有方法，则该方法只是子类的一个新方法，与父类中的私有方法无关
子类方法的可访问性必须与父类的可访问性保持一致，或是更加公开
不能重写静态方法

super关键字

在子类方法中访问父类的属性或方法——super.属性名/super.方法

final关键字

修饰变量——不可改变
修饰方法——不可被子类重写
修饰类——不可被子类继承

内部类

在一个类体之内再定义一个类——内部类/外部类
成员内部类/局部内部类/静态内部类/匿名内部类

匿名内部类

匿名内部类不能有构造方法
匿名内部类不能定义任何静态方法

单例模式

构造方法私有
用一个私有的静态变量引用实例
提供一个公有的静态方法实现

package Chapter0824;
        
//单例模式  SingletonDemo.java

class Singleton{
    private static Singleton instance=null;
    private Singleton(){

    }
    public static Singleton getInstance(){
        //在第一次使用时生成了实例，提高了效率
        if(instance==null){
            instance=new Singleton();
        }
        return instance;
    }
}

public class SingletonDemo {
    public static void main(String[] args){
        Singleton s1=Singleton.getInstance();
        Singleton s2=Singleton.getInstance();
        if(s1==s2){
            System.out.println("s1和s2是一个对象。");
        }
    }

}

单例模式（Singleton Pattern）是 Java 中最简单的设计模式之一。这种类型的设计模式属于创建型模式，它提供了一种创建对象的最佳方式。

这种模式涉及到一个单一的类，该类负责创建自己的对象，同时确保只有单个对象被创建。这个类提供了一种访问其唯一的对象的方式，可以直接访问，不需要实例化该类的对象。

注意：

1、单例类只能有一个实例。
2、单例类必须自己创建自己的唯一实例。
3、单例类必须给所有其他对象提供这一实例。

一般用于数据库连接。

抽象类（abstract）

只有声明，没有方法
抽象类可以包含成员变量以及构造方法，但不能通过构造方法创建实例

package Chapter0824;

public abstract class Animal {
    public String name;
    public Animal(String name){
        this.name=name;
    }
//    public Animal(){
//        
//    }
    public String getName(){
        return this.name;
    }
    public void setName(){
        this.name=name;
    }
    //抽象方法，行动
    public abstract void action();
    //抽象方法，叫
    public abstract void call();
    //定义子类Horse和Bird类，继承Animal，并且实现action和call两个抽象方法
}

package Chapter0824;

public class Horse extends Animal{
    public Horse(){
        super("马");
    }
    @Override
    public void action() {
        System.out.println("冲啊");
    }

    @Override
    public void call() {
        System.out.println("嗷嗷");
    }
}

package Chapter0824;

public class Bird extends Animal{
    public Bird(){
        super("鸟");
    }
    @Override
    public void action() {
        System.out.println("飞啊");
    }

    @Override
    public void call() {
        System.out.println("叽叽");
    }
}

接口（implements）

降低各模块之间的耦合，提供可扩展性和可维护性
单一继承，不支持多重继承——通过接口来弥补
Java允许一个类实现多个接口
一个接口继承（extends）多个接口时，多个接口之间使用“,”隔开
接口只能继承接口，不能继承类
访问符可以是public或缺省，如果缺省访问符，则默认采用包权限访问控制，即在相同包中才可以访问该接口
接口体内定义的方法——public，可省略
接口体内的变量——常量 static final 不可改变

package Chapter0824;

public interface  Book {
    int A=1;//public static final
    void display();//public
}

package Chapter0824;

public class MathBook implements Book{

    public MathBook(){

    }
    public void display() {
//        Book.A=12;//final 不能改变
        System.out.println("MathBook.");
    }

    public static void main(String[] args){
        MathBook mathBook=new MathBook();
        mathBook.display();
    }

}

package Chapter0824;

public class ChineseBook implements Book{

    public ChineseBook(){

    }
    public static void main(String[] args){
        ChineseBook chineseBook=new ChineseBook();
        chineseBook.display();
    }

    public void display() {
        System.out.println("ChineseBook");
    }
}

接口的继承

package Chapter0824;

public interface  Book extends A,B,C{
    int A=1;//public static final
    void display();//public
}

接口和抽象类不能被实例化，需要被其他类实现或继承
接口和抽象类的类型变量都可以指向其实现类或子类的实例对象
接口和抽象类都可以包含抽象方法

接口和抽象类的区别

接口中定义的变量默认是public static final，且必须赋值，其实现类中不能重新定义，也不能改变其值，即接口中定义的变量都是最终的静态变量
接口中定义的方法都默认缺省的时public，而抽象类则与类一样默认是缺省的
一个类只能有一个直接父类

面向接口编程

简单工厂模式

instanceof

鉴别对象的真正类型
引用类型变量 instanceof 引用类型
p instanceof People （返回Boolean类型）
用于判断前面的引用类型变量是不是后面的引用类型（子类、实现类的实例/类本身）

2018.8.24