百行代码理解Java接口、抽象方法与执行顺序

public class Mainf implements A{//在java中 一个类中不能继承多个接口，但是可以通过一个接口继承多个接口来实现
	int t;
	
	static{
		System.out.println("我是静态代码块最先执行，类加载的时候我就执行了，而且只执行这一次");
	}
	
	public Mainf() {
		{
			System.out.println("我是构造函数中的构造代码块，我第三在main函数之后执行");
		}
		t = 10;//建议在构造函数或提供setters方法对变量赋值, 直接给成员变量赋值，Java是不推荐的，因为这样会破坏它的封装性
		int t = 10;//在构造函数内部声明的变量的作用域，仅限构造函数内部，所以在main方法中无法使用构造函数中声明的变量，要使用只能将变量的定义为类级的
		//在Java中，变量的作用域分为四个级别：类级、对象实例级、方法级、块级。
		//简单的说就是一个方法不能直接访问只属于另一个方法中的东西。
		System.out.println("我是构造函数，" + "我在构造代码块之后执行，" + "我有一个变量t = " + t);
	}
	@Override//对三个接口的所有抽象方法进行重写，来进行调用
	public void absf(){
        System.out.println("my name is " + name1 + "我重写了接口A的抽象方法");
        absff();//在普通方法中可以直接调用其他普通方法
        absfff();
    }
	
	public void absff(){
        System.out.println("my name is " + name2 + "我重写了接口B的抽象方法");
    }
	
	public void absfff(){
        System.out.println("my name is " + name3 + "我重写了接口C的抽象方法");
    }
	
	public static void staf() {
		System.out.println("我是静态方法");
	}
    public static void main(String[] args){//main方法是特殊的方法，不属于类所有
    	//除了静态代码块以外，其他所有方法，对象的实现操作都必须经过main方法
    	//main()方法中字符串参数数组作用是接收命令行输入参数的，命令行的参数之间用空格隔开
    	System.out.println("我是main方法，我第二执行");
    	staf();//静态方法可以直接调用
    	
    	Mainf m = new Mainf();
    	m.absf();//非静态方法必须在创建对象后执行
    	//absf();//main方法是静态方法不能调用非静态的方法，哪怕是同类中也不行，只能调用静态方法
    	
        D d = new E();//抽象类中的普通方法不能通过实例化对象来实现，可以通过实例化子类，父类引用来调用父类的方法。
        System.out.println(d.fun());
        
        E t = new E();//子类对象也可以直接引用父类的方法
        System.out.println(t.fun());
    }
}
/**
 * 三个接口
 */
interface A extends B,C {//接口可以多继承
    int age = 18;//接口中成员变量默认是public static final
    public static final String name1 = "java";
    public abstract void absf();//方法默认是public abstract，可以不写
}

interface B {
    int age = 19;
    public static final String name2 = "C++";
    public abstract void absff();
}

interface C {
    int age = 20;
    public static final String name3 = "python";
    public abstract void absfff();
}



/**
 * 抽象类
 */
abstract class D extends X {
	int ans;
	
	public D() {//抽象类的构造函数用来初始化抽象类的一些字段
		System.out.println("我是父类的构造方法");
		//构造方法不可继承，但是可以供子类用super（）或者super（参数，参数，...）调用
		//一般默认super();调用父类的构造方法
	}
	
	abstract void abs();
	
	public String fun() {
		String m = prifun();//同一类中可以直接调用其私有方法
		return m;
	}
	
	private String prifun() {//私有方法只能在本类中调用
		return "我是私有方法";
	}
}

/**
 * 继承了抽象类的普通类
 */
class E extends D{
	public E() {
		System.out.println("我是子类的构造方法");
	}
	
	@Override
	void abs(){//子类继承了一个抽象的父类必须重写其所有抽象方法
		System.out.println("重写抽象方法");
	}
	public void norm(){
		System.out.println("普通方法");
	}
	public void use(){
		norm();//同一类的普通方法可以直接调用
		fun();//子类可以直接调用父类的普通方法
		//prifun();//子类不能调用父类的私有方法
	}
}

class X implements A,B,C{//接口可以多实现
	
	@Override
	public void absfff() {
		// TODO Auto-generated method stub
		
	}

	@Override
	public void absff() {
		// TODO Auto-generated method stub
		
	}

	@Override
	public void absf() {
		// TODO Auto-generated method stub
		
	}

	public X() {
		System.out.println("我是父类的父类的构造方法，从某种意义上这实现了类的多继承，但这种方法有很多未知问题");
	}
}

代码结果：

我是静态代码块最先执行，类加载的时候我就执行了，而且只执行这一次
我是main方法，我第二执行
我是静态方法
我是构造函数中的构造代码块，我第三在main函数之后执行
我是构造函数，我在构造代码块之后执行，我有一个变量t = 10
my name is java我重写了接口A的抽象方法
my name is C++我重写了接口B的抽象方法
my name is python我重写了接口C的抽象方法
我是父类的父类的构造方法，从某种意义上这实现了类的多继承，但这种方法有很多未知问题
我是父类的构造方法
我是子类的构造方法
我是私有方法
我是父类的父类的构造方法，从某种意义上这实现了类的多继承，但这种方法有很多未知问题
我是父类的构造方法
我是子类的构造方法
我是私有方法

知识点汇总：

• 在Java中一个类中不能继承多个接口，但是可以通过一个接口继承多个接口来实现

• 建议在构造函数或提供setters方法对变量赋值, 直接给成员变量赋值，Java是不推荐的，因为这样会破坏它的封装性

• 在构造函数内部声明的变量的作用域，仅限构造函数内部，所以在main方法中无法使用构造函数中声明的变量，要使用只能将变量的定义为类级的。简单的说就是一个方法不能直接访问只属于另一个方法中的东西。

• 在Java中，变量的作用域分为四个级别：类级、对象实例级、方法级、块级。

• 同一类中，在普通方法中可以直接调用其他普通方法

• main方法是特殊的方法，不属于类所有
  除了静态代码块以外，其他所有方法，对象的实现操作都必须经过main方法
  main()方法中字符串参数数组作用是接收命令行输入参数的，命令行的参数之间用空格隔开

• 静态方法可以直接调用，非静态方法必须在创建对象后执行

• main方法是静态方法，不能调用非静态的方法，哪怕是同类中也不行，只能调用静态方法

• 抽象类中的普通方法不能通过实例化对象来实现，可以通过实例化子类，父类引用来调用父类的方法。
  子类对象也可以直接引用父类的方法

• 一个接口可以继承多个接口，一个类可以实现多个接口

• 接口中成员变量默认是public static final

  接口中的方法默认是public abstract，都可以不写

• 抽象类的构造函数用来初始化抽象类的一些字段

• 构造方法不可继承，但是可以供子类用super（）或者super（参数，参数，…）调用

• 一般一般子类的构造方法中默认super();调用父类的构造方法

• 同一类中可以直接调用其私有方法

  私有方法只能在本类中调用

• 子类继承了一个抽象的父类必须重写其所有抽象方法

• 子类可以直接调用父类的普通方法，但不能调用父类的私有方法