【Java】类、对象与接口

抽象类 abstract

抽象类：不具体的类，不能实例化，用于继承

1. abstract 修饰类、方法
2. 抽象类不能实例化
3. 抽象类中不一定有抽象方法，有抽象方法一定是抽象类
4. 抽象类的子类要么是抽象的，要么实现父类中所有抽象方法
5. abstract不能修饰变量
6. abstract不能与static、final、private同用
7. 抽象类有构造器

// 抽象类
abstract class Father {
        public Father() {
	        System.out.println("in Father() constructor");
        }
        public void test1(){
                System.out.println("in Father test1()");
        }	
        public abstract void test2(); // 用abstract定义了一个抽象方法

        //static/final/private abstract void test2(); 不能同用
}

class Son extends Father{
        // 实现父类中的抽象方法test2()
        public void test2(){
	        System.out.println("in Son test2()");
        }
}

public class AbstractTest{
        public static void main(String[] args){
	        //Father f = new Father(); 抽象类不能实例化
	        Father f = new Son();
        }
}

接口 interface

接口是一种特殊的抽象类，用来定义规范，让子类实现。接口的所有方法都是默认抽象和公开的。利用 interface，我们即可实现传统的面向接口编程，在一些大型项目中，某些功能还没有实现，我们就可以先做接口，最后再一一实现。

1. 接口用 interface进行定义
2. 不能实例化
3. 子类要实现接口中所有抽象方法
4. 变量必须是常量（public static final）
5. 成员方法都是抽象的（public abstract），默认抽象，不需要加 abstract
6. 接口没有构造器

interface Father {
        // 接口中有抽象方法
        public void test1();
        public void test2();
}

class Son implements Father {
        // 接口的子类要实现父类中所有抽象方法
        public void test1() {
                System.out.println("in test1()");
        }
        public void test2() {
	        System.out.println("in test2()");
        }
}

public class InterfaceTest {
        public static void main(String[] args) {
                //通过实例化子类，也即是多态的实例化方式
	        Father f = new Son();
	        f.test1();
	        f.test2();
        }
}

类、接口之间的继承关系

类与类之间：extends 继承关系，只能单继承，可以多层次继承

类与接口之间：implements 实现关系，可以单实现，也可以多实现，即一个类可以实现多个接口，在实现时需要将多个接口中的所有抽象方法都实现

interface Father {
        public void test1();
}

interface Mother {
        public void test2();
}

class Son implements Father,Mother {
        public void test1() {
                System.out.println("in test1()");
        }
        public void test2() {
	        System.out.println("in test2()");
        }
}

接口与接口之间：extends 继承关系，可以单继承，也可以多继承

interface A {}
interface B {}
interface C extends A,B {}

单例模式

让类只能产生一个实例对象

// 饿汉式
class Singleton {
	private static Singleton s = new Singleton();
        //将构造器私有化，调用构造器需要本类方法来调用
	private Singleton() {}
	public static Singleton getInstance() {
		return s;
	}
}

public class SingletonTest {
	public static void main(String[] args) {
		Singleton s1 = Singleton.getInstance();
		Singleton s2 = Singleton.getInstance();
		System.out.println(s1);
		System.out.println(s2);
	}
}

// 懒汉式
class Singleton {
	private static Singleton s;
	private Singleton() {}
	public static Singleton getInstance() {
                if(s == null) {
                        s = new Singleton();
                }
		return s;
	}
}