总结：一般类，抽象类，接口之间的继承、实现关系

一般类：

一、一般类（普通类）实现 某个接口情况：

一般类可以通过关键字 implements 来实现 一个或多个 接口；

如下代码↗：

//接口1
public interface Interface_One {
       void inMethod();
}

//接口2
public interface Interface_Two {
       double number = 111.111;
}

//一般类
public class General_Class implements Interface_One,Interface_Two {

	//操作继承的接口常量number
	double variable = 11.11+number;
		
	//重写接口抽象方法
	public void inMethod() {
		System.out.println("一般类重写接口抽象方法");
		System.out.println("variable的值："+variable);
	}
	
	public static void main(String [] args){
		General_Class gc = new General_Class();
		gc.inMethod();
	}
}

代码中一般类General_Class，实现了两个接口，那么一般类不仅要继承接口的常量，还要重写接口的抽象方法；

代码输出结果：

一般类重写接口抽象方法
variable的值：122.221

---

二、一般类（普通类）继承 某个一般类情况：

一般类可以通过关键字 extends 来继承 一般类，只能继承一个；

如下代码↗：

//一般类General 
public class General {
	int number = 111;
	void Method(){
		System.out.println("父类方法");
	}
}

//一般类继承一般类
public class General_Class extends General {
	//可以继承或者重写一般类的成员变量和方法
	//重写一般类的方法
	void Method(){
		System.out.println("重写父类方法");
	}

	public static void main(String [] args){
	General_Class gc = new General_Class();
	gc.Method();
	System.out.println("打印继承的成员变量number："+gc.number);
    }
}

代码中一般类General_Class，继承一般类 General 作为自己的父类 ，那么一般类可以继承或者重写父类的成员变量和方法；

代码输出结果：

重写父类方法
打印继承的成员变量number：111

---

三、一般类（普通类）继承 某个抽象类情况：

一般类可以通过关键字 extends 来继承 抽象类，只能继承一个；

如下代码↗：

//抽象类
public abstract class abstract_Class {
	//声明成员变量
	double variable = 11.11;
        //声明抽象方法
	abstract void abMethod();
	 //声明一般方法
	void Method(){
		System.out.println("抽象类一般方法，由子类继承");
	}
}

//一般类继承抽象类	
public class General_Class extends abstract_Class {
	
	//一般类继承抽象类的其他方法，重写抽象类的抽象方法；
	void abMethod(){
		System.out.println("一般类重写了抽象类的抽象方法");
	}

	public static void main(String[] args) {
		General_Class gc = new General_Class();
		//调用重写的抽象类方法
		gc.abMethod();
		//调用继承的方法
		gc.Method();
		//调用继承的成员变量
		System.out.println("打印继承的成员变量variable："+gc.variable);
	}
}

代码中一般类General_Class，继承抽象类 abstract_Class 作为自己的父类 ，那么一般类可以继承抽象类的成员变量和实例方法，必须重写抽象类中的抽象方法；

代码输出结果：

一般类重写了抽象类的抽象方法
抽象类一般方法，由子类继承
打印继承的成员变量variable：11.11

---

四、一般类（普通类）继承 某个抽象类的同时、实现某个接口情况：

当一般类继承某个抽象类的同时，还实现某个接口，那么一般类不仅要继承 抽象类的成员变量和实例方法、接口的常量，还要重写 抽象类和接口中的抽象方法；

如第三点中，改为 ：public class General_Class extends abstract_Class implements Interface_One { }

那么一般类General_Class ，就要继承 抽象类的成员变量和实例方法、接口的常量，还要重写 抽象类和接口中的抽象方法；

---

一般类（普通类）总结：

1、一般类可以继承一般类；

2、一般类可以继承抽象类；

3、一般类可以实现接口；

4、一般类可以继承抽象类的同时，实现接口；

---

抽象类：

一、抽象类 继承 某个一般类情况：

当抽象类继承某个一般类时，那么抽象类就可以继承一般类的成员变量和实例方法，或者隐藏继承的成员变量、重写继承的实例方法；

如下代码↗：

//一般类
public class classTest {
	 //声明成员变量
	double variable = 11.11;
	 //声明一般方法
	void Method(){
		System.out.println("一般类的实例方法");
	}
}

//抽象类继承某个一般类
public abstract class abstract_Class extends classTest {	
	//重写一般类的实例方法
	void Method(){
		System.out.println("重写了一般类的实例方法");
	}
}

对于抽象类是不能实例化对象的，所以抽象类所继承和重写的方法，要通过其抽象类的子类对象进行调用；

---

二、抽象类 继承 某个抽象类情况：

当抽象类继承某个抽象类时，那么这个抽象类就可以继承父类的成员变量和实例方法，抽象方法；

如下代码↗：

//抽象类2
public abstract class abstract_Class_Two {
	double variable = 11.11;
	// 声明抽象方法
	abstract void abMethod();
	// 声明一般方法
	void Method() {
		System.out.println("抽象类一般方法，由子类继承");
	}
}

//抽象类继承某个抽象类
public abstract class abstract_Class extends abstract_Class_Two {	
	
	//可以继承父类的成员变量和实例方法，抽象方法
}

以上代码中，抽象类abstract_Class 继承了 抽象类abstract_Class_Two ，并选择继承 父类abstract_Class_Two 的成员变量和全部方法，不强制要求重新父类的抽象方法；

---

三、抽象类 实现 某个接口情况：

当抽象类 实现 某个接口时，和第二点差不多，这个抽象类就可以继承接口的 常量和抽象方法；

如下代码↗：

public abstract class abstract_Class implements Interface_One {    
}

---

四、抽象类 继承 某个类的同时、实现某个接口情况：

当抽象类 继承 某个类的同时、也可以实现某个接口；

1、抽象类 继承 抽象类的同时、实现某个接口；

public abstract class abstract_Class extends abstract_Class_Two implements Interface_Two {    
}

2、抽象类 继承 一般类的同时、实现某个接口；

public abstract class abstract_Class extends classTest implements Interface_Two {    
}

---

抽象类总结：

1、抽象类可以继承一般类；

2、抽象类可以继承抽象类；

3、抽象类可以实现接口；

4、抽象类 继承 某个类的同时、实现某个接口；

---

接口：

一、接口 继承 某个一般类情况：错误，接口不能继承一般类 ；

如：public interface Interface_One extends classTest {}   //是错误的

二、接口 继承 某个抽象类情况：错误，接口不能继承抽象类 ；

如：public interface Interface_One extends abstract_Class{}   //是错误的

三、接口 继承 某个接口情况：

当一个接口 继承 某个接口时，那么这个接口就继承了另一个接口的 常量和抽象方法；

如：

//接口2
public interface Interface_Two {
       double number = 111.111;
       void inMethods();
}

//接口 继承 接口 ；
public interface Interface_One extends Interface_Two {	
}

---

四、接口 实现 某个接口情况：错误，接口不能实现某个接口 ；

如：public interface Interface_One implements Interface_Two{}   //是错误的

接口总结：

1、接口是不能继承类的；

2、接口 与 接口 之间是通过关键字 extends 进行关联的，而不是关键字 implements；