抽象类与抽象方法
abstract修饰符定义的类或者方法。
规则：
- 抽象类与抽象方法必须用abstract修饰
- 抽象类不可实例化，可创建子类对象。
- 抽象类可以有成员变量，普通方法，构造器，初始化块，内部类（接口，枚举）。
public abstract class Shape {
{
System.out.println("执行shape初始化块.");
}
private String color;
public abstract double getzc();
public abstract String getType();
public Shape() {
}
//抽象类本身并不能实例化，但可声明子类对象
//可以有构造器
public Shape(String color)
{
System.out.println("执行shape构造器");
this.color = color;
}
public String getColor() {
return color;
}
public void setColor(String color) {
this.color = color;
}
}
public class Triangle extends Shape {
private double a;
private double b;
private double c;
public Triangle(String color,double a, double b, double c) {
super(color);
this.setSide(a, b, c);
}
public void setSide(double a, double b, double c)
{
if(a>=b+c||b>=a+c||c>=a+b)
{
System.out.println("三角形两边之和必须大于第三边");
return;
}
this.a = a;
this.b = b;
this.c = c;
}
@Override
public double getzc() {
return a+b+c;
}
@Override
public String getType() {
return "三角形";
}
public static void main(String[] args) {
Shape s = new Triangle("black", 3, 4, 5);
System.out.println(s.getType()+"\t"+s.getzc());
}
}接口
使用interface关键字定义。接口与接口直接可以实现多继承。
接口中可包含静态常量（接口默认添加public static final），抽象方法，静态方法，默认方法，内部类
package aboutinterface;
public interface Output {
//接口中的成员变量只能是常量--系统默认public static final
//普通方法默认为public abstract ;默认方法必须提供方法实现
int MAX_A =50;
void out();
void getData(String s);
//默认方法必须显式写出来
default void print(String...s)
{
System.out.println(s);
}
default void test()
{
System.out.println("默认方法test()");
}
//静态方法
static String staticTest()
{
return "接口中的静态方法";
}
}package aboutinterface;
public class OutputTest {
public static void main(String[] args) {
//访问接口中的静态常量
System.out.println(Output.MAX_A);
//访问接口中的静态方法
System.out.println(Output.staticTest());
}
}public class InterfaceInheritanceTest {
public static void main(String[] args) {
System.out.println(interfaceC.i_A);
System.out.println(interfaceC.i_B);
System.out.println(interfaceC.i_C);
}
}
interface interfaceA
{
int i_A = 5;
void testA();
}
interface interfaceB
{
int i_B = 6;
void testB();
}
//接口间可以多继承
interface interfaceC extends interfaceA,interfaceB
{
int i_C = 7;
void testC();
}
接口实现
public class InterfaceTest implements A {
public static void main(String[] args) {
InterfaceTest it = new InterfaceTest();
it.print();
}
@Override
public void print() {
System.out.println("print...");
}
}
interface A {
void print();
}
接口与抽象类的区别
- 接口中包含抽象方法，静态方法与默认方法，不能为普通方法提供实现，抽象类可包含普通方法
- 接口中只能定义静态常量，不能定义普通成员变量，抽象类即可定义普通成员变量也可定义静态常量
- 接口中不能有构造器，抽象类中可以有构造器为子类提供初始化
- 抽象类只能单继承，接口可多继承，一个类只能继承一个抽象类，但一个类可以是实现多个接口