抽象类

抽象类是为方法覆写而提供的类，定义抽象类和抽象方法需要使用关键字abstrast。
例子：

abstract class Imethod{           //抽象类
	public abstract void method();//抽象方法
	public void setter() {}
	public void getter() {}
	//抽象类中也可以定义普通方法
}

要使用抽象类，要注意以下几个点：
（1）必须有子类继承抽象类，与其他类一样使用extends进行继承
（2）抽象类的子类(子类不是抽象类)必须覆写抽象类中的所有抽象方法
（3）如果要对抽象类进行实例化，就需要利用多态性，用向上转型的方法完成实例化

例子：

abstract class Imethod{           //定义抽象类
	public abstract void method();//定义抽象方法
	public void setter() {}
	public void getter() {}
}

class method extends Imethod{    //子类继承抽象类
	public void method() {
		System.out.println("覆写抽象类方法");
	}
	//对抽象方法进行覆写
}

public class Java {
	public static void main(String[] args) {
		Imethod test = new method();//利用多态性，向上转型进行实例化
		test.method();
	}

}

/*
输出结果：
覆写抽象类方法
*/

在使用抽象类时要注意不能使用final关键字来定义抽象类和抽象方法，否则会报错。
还有一点就是在抽象类中定义构造方法时，子类继承时会默认调用父类中的无参构造方法，如果这时抽象类中没有无参构造方法，则子类需要使用super()来调用父类中的构造方法。
例子：

abstract class Imethod{
	
	int x;
	public abstract void method();
	
	public Imethod(int x) {     //定义只有一个参数的构造方法
		this.x = x;
	}
	
}

class method extends Imethod{
	
	public method(int x) {
		super(x);               //调用抽象类中的构造方法，super()调用父类的构造方法
	}
	
	public void method() {
		System.out.println(x);
	}
	
}

public class Java {
	public static void main(String[] args) {
		int x=666;
		Imethod test = new method(x);
		test.method();
	}
}

/*
输出结果：
666
*/

抽象类中允许不定义抽象方法，但即使没有抽象方法，也不能直接使用new关键字直接实例化，但抽象类中可以使用static方法，该方法就不受到抽象化实例对象的性质。
例子：

abstract class Imethod{
	
	public abstract void method();
	
	public static Imethod function() {
		return new fun();                 //实例化子类对象
	}
	
}

class fun extends Imethod{
	
	public void method() {
		System.out.println("666");
	}
}

public class Java {
	public static void main(String[] args) {
		Imethod test = Imethod.function();     //调用function方法返回实例化对象
		test.method();
	}
}

/*
输出结果：
666
*/

接口

定义接口需要用到interface关键字，在接口中定义使用public访问权限的方法是抽象方法，其他方法可以用default访问权限和static访问权限，还可以定义全局变量。
例子：

interface Imethod{
	public static int x = 666;  //定义全局变量
	public abstract void fun1();//定义抽象方法
	default void fun2() {       //定义其他方法
		System.out.println();
	}
}

当定义的接口内有抽象方法，就无法被直接实例化，其使用注意需要以下几点：
（1）接口需要被子类实现，使用implements关键字实现，可以实现多个父接口
（2）子类如果不是抽象类，则必须覆写接口中的所有抽象方法
（3）接口对象也可以利用向上转型进行实例化
例子：

interface Imethod1{                                         //定义接口类
	public static int x = 666;                              //定义全局变量
	public abstract void fun1();                            //定义抽象方法
	
	default void fun2() {                                   //定义其他方法
		System.out.println("接口方法fun2()被调用");
	}
}

interface Imethod2{
	default void fun3() {
		System.out.println("接口方法fun3()被调用");
	}
}

class method implements Imethod1,Imethod2{                  //运用implements关键字实现多个接口
	public void fun1() {                                    //覆写接口中的抽象方法
		System.out.println("接口内抽象方法fun1()被覆写");
	}
}
public class Java {
	public static void main(String[] args) {
		method test = new method();
		
		test.fun1();
		test.fun2();
		test.fun3();
	}
}

/*
输出结果：
接口内抽象方法fun1()被覆写
接口方法fun2()被调用
接口方法fun3()被调用

*/

还需要注意的是如果实现父接口的同时，也需要继承父类，则要实现混合运用要用到的语法如下：

interface Imethod1{
}//接口

interface Imethod2{
}//接口

class function{
}//普通类

class method extends function implements Imethod1,Imethod2{
}
//要实现混合应用则要注意，要先进行继承，然后再实现接口，继承的父类依然只能有一个，但父接口还是可以实现多个