java_父类和接口的引用类型的代码及其详解_原创

今天学习了java中的一个知识点，很是重要，自己就把他做了一个详细的注解，避免忘记！

主要是java中有关于抽象了和接口的引用类型变量保存子类或实现类得访问的问题，好了，其它的废话不多说了，直接看代码，和代码的详细注解！

以下代码都是通过eclipse编辑和运行通过的

下面是接口A.java的代码

/**
 * 抽象类A，中有抽象方法，普通方法和成员变量
 * */

package com.zj.inter;

public abstract class A {
	//成员变量
	public int i = 20;
	public String name = "小米";

	//抽象类
	public abstract void m1();

	//普通方法
	public void m2() {
		System.out.println("A.m2()..");
	}

	public void m3() {
		System.out.println("A.m3()..");
	}
}

下面是接口Inf1.java的代码

/**
 * 接口Inf1，有抽象方法m4()
 * */
package com.zj.inter;

interface Inf1 {
	//抽象方法m4()
	public abstract void m4();
}

下面是接口Inf2.java的代码

/**
 * 接口Inf2，有抽象方法m5()
 * */
package com.zj.inter;

interface Inf2 {
	//抽象方法m5()
	public abstract void m5();
}

下面是接口B.java的代码

/**
 * B类，继承了抽象类A类，实现了接口Inf1和Inf2
 * */

package com.zj.inter;

public class B extends A implements Inf1, Inf2 {

	public int i = 3;//隐藏了A中的i
	public int j = 6;

	// 抽象类A中抽象方法的重写
	@Override
	public void m1() {
		System.out.println("B.m1()..");
	}

	// 抽象类A中的普通方法的重写
	public void m2() {
		System.out.println("B.m2()..");
	}

	// 接口Inf1中的抽象方法的实现
	@Override
	public void m4() {
		System.out.println("B.m4()..");
	}

	// 接口Inf2中的抽象方法的实现
	@Override
	public void m5() {
		System.out.println("B.m5()..");
	}

	/**
	 * fun1()是测试创建B的引用类型（B b = new B()）后，b所能够访问的成员
	 * */
	public void fun1() {
		
		B b = new B();//创建B的引用类型变量

		// B中的i隐藏了A中的i
		System.out.println("b.i = " + b.i);

		// 不是静态，不能这样访问A中的i
		// System.out.println(b.A.i);

		System.out.println("b.name = " + b.name);
		System.out.println("b.j = " + b.j);//访问的B类中的成员变量j

		b.m1();// B.m1().. B重写A类中的抽象方法
		b.m2();// B.m2().. B中重写A类中的m2()
		b.m3();// A.m3().. 调用A类中被继承的普通函数
		b.m4();// B.m4().. B类中实现了Inf1中的接口
		b.m5();// B.m5().. B类中实现了Inf2中的接口
	}

	/**
	 * fun2():父类A的引用类型变量保存子类B的对象 此时引用类型变量访问成员方法时只能访问父类中出现的成员方法，如果引用 的对象所属子类
	 * */
	public void fun2() {
		A a = new B();
		/**
		 * 成员变量的访问与成员函数的访问不同，成员变量不是公用的，是每个对象各自有一份，
		 * 故A的引用只访问A的成员变量，不管子类或实现类得接口
		 * */
		System.out.println("a.i = " + a.i);// A中的i
		System.out.println("a.name = " + a.name);
		// 父类A的引用类型，只能访问A中
		// System.out.println(a.j);

		/**
		 * A a = new B() A的引用类型保存子类的对象，使用引用类型访问成员方法
		 * 时只能访问A类中有的成员方法，如果A类中的成员方法在子类中有重写的这访问到的 是重写的方法
		 * */
		a.m1();// B.m1()..
		a.m2();// B.m2()..
		a.m3();// A.m3().. 没有重写，访问到的是父类的
		// a.m4();// A类中没有m4()函数
		// a.m5();// A类中没有m5()函数
	}

	/**
	 * 父类（接口）引用类型保存子类（实现类）的对象，使用引用类型访问成员方法 时只能访问父类（接口）中有的成员方法，如果父类（接口）中的成员方法在子
	 * 类（实现类）中有重写，则这访问到的是重写的成员方法
	 * */
	public void fun3() {
		Inf1 inf1 = new B();

		/**
		 * 注释了的不是接口Inf1中成员，故没办法通过Inf1创建的引用类型变量来访问
		 * */
		// System.out.println(inf1.i);
		// System.out.println("inf1.name = "+inf1.name);
		// System.out.println(inf1.j);

		// inf1.m1();
		// inf1.m2();
		// inf1.m3();
		inf1.m4();// 只有在接口类中有的才能被访问
		// inf1.m5();
	}

	public static void main(String[] args) {
		B b1 = new B();

		b1.fun1();// 调用fun1函数
		System.out.println("======1======");

		b1.fun2();// 调用fun2函数
		System.out.println("======2======");

		b1.fun3();// 调用fun3函数
		System.out.println("======2======");
		
	}

}

注册优快云还是有段时间了，自己学了的重新写一遍还是很有必要的，以后常写~~