Java基础知识学习——面向对象设计模式、抽象方法、静态方法及接口

一.知识点汇总

设计模式：
1.单例(singleleton)设计模式 饿汉式 vs懒汉式
单例设计模式：就是采取一定的方法保证在整个的软件系统中，对于某个类只能存在一个对象实例。
创建单例设计模式：①私有化类的构造器②内部创建类的对象(此对象要求声明为静态的)③提供公共的静态的方法返回类的对象
代码块：总结由父及子，静态先行
属性可以赋值的位置：①默认初始化②显示初始化/在代码块中赋值
③构造器中初始化④有了对象以后可以通过“对象.属性”或者“对象.方法”的方式进行赋值 执行先后顺序为：①-》②-》③-》④

public class ModelTest {
    public static void main(String[] args) {
        //实例化测试
        Bank bank1 = Bank.getInstance();
        Bank bank2 = Bank.getInstance();
        System.out.println(bank1 == bank2);
    }
}
//饿汉式
class Bank {
    //私有化构造器
    private Bank() {
    }
    //内部创建类的对象
    private static Bank instance = new Bank();
    //提供公共的静态方法返回类的对象
    public static Bank getInstance() {
        return instance;
    }
}
//懒汉式
class Order {
    //私有化构造器
    private Order() {
    }
    //声明当前类的对象没有初始化
    private static Order stance = null;

    public static Order getStance() {
        if (stance == null) {
            stance = new Order();
        }
        return stance;
    }
}

二.知识点汇总

一.static关键字的使用
静态的，可以用来修饰：属性、方法、代码块、内部类
1利用static修饰的属性：静态变量
栈：存放局部变量；堆：new出来的结构：对象数组；方法区：类的加载信息、静态域、常量池
2.使用static修饰方法静态方法 随着类的加载而加载通过“类.静态方法”来调用，静态方法中只能调用静态的方法 或属性，非静态方法中既可以调用非静态的方法和属性也可以调用静态的属性方法，在静态方法内不能使用this和super。

public class StaticTest {
    public static void main(String[] args) {
        StaticTest staticTest=new StaticTest();
        staticTest.method();
    }
    //若无static修饰则不能直接在main方法中调用
    public static void method(){
        System.out.println("此方法是静态方法");
    }
}
class TestStatic{
    //修饰属性
    public static int num;
    //修饰方法
    public static void method1(){
        System.out.println("修饰方法示例");
    }
    //修饰代码块
    static {
         String ss="代码块";
    }
}

二.abstract关键字abstract抽象的
1.abstract可以用来修饰的结构：类、方法
2.abstract修饰类：抽象类,此类不能实例化
抽象类中一定有构造器子类实例化时调用（涉及：子类对象实例化的全过程）,开发中都会提供抽象类的子类让子类对象实例化，完成相关的操作.
3.abstract修饰方法：抽象方法
抽象方法只有方法的声明，没有方法体public abstract void eat();
包含抽象方法的类，一定是一个抽象类,反之抽象类中不一定有抽象方法
若子类重写了父类中的所有抽象方法，子类方可实例化.
abstract使用上的注意点：不能用来修饰：属性、构造器等结构;不能用来修饰私有方法、静态方法、final的方法、final的类.
代码示例：

public class AbstractTest {
    public static void main(String[] args) {
        instance ins=new instance();
        ins.method();
    }

}
//定义抽象类
abstract class TestAbstract{
    private int num;
    //定义抽象方法
    public abstract void method();
}
//继承抽象类
class instance extends TestAbstract{
    //实现父类中的抽象方法
    @Override
    public void method() {
        System.out.println("抽象方法的实现");
    }
}

三.interface接口
接口的使用：1.接口使用interface来定义.
2.java中接口和类是并列结构.
3.如何定义接口，定义接口中的成员,jdk7及以前：只能定义全局常量和抽象方法.
全局常量： public static final 抽象方法：public abstract.
jdk8还可以定义静态方法，默认方法.
知识点一：接口中定义的静态方法只能通过接口来调用.
知识点二：通过实现类的对象，可以调用接口中的默认方法.
4.接口中不能定义构造器意味着接口不可以实例化.
5.java开发中接口通过让类实现(implements)的方式来使用,如果实现类覆盖了接口中所有的抽象方法则此实现类就可以实例化.
6.java可以实现多个接口，弥补了Java单继承性的局限,格式：class AA extends BB implements CC，DD.
7.接口与接口之间可以继承而且可以多继承,接口的具体实现体现了多态性.

public class InterfaceTest {
    public static void main(String[] args) {
        instant ins=new instant();
        ins.method();
    }
}
//定义接口
interface TestInterface{
    public static void compare() {
        System.out.println("compare");
    }
    public default void method() {
        System.out.println("默认方法");
    }
    default void method1() {
        System.out.println("默认方法");
    }
}
//实现接口
class instant implements TestInterface{
    //重写接口中的方法
    public void method(){
        System.out.println("这是重写了接口中的method方法");
    }
}