(笔记)关于java中的一些有关问题
第一题:
package william; abstract class Name { private String name; public abstract boolean inStupidName(String name){ System.out.println("okay"); }; }
报错:
问题:1) Abstract methods do not specify a body;
2) This method must return a result of type boolean;
3) The field Name.name is never read locally;
第二题:
package william; public class Outer { private String str="this is outter"; class Inner{ String str="this is inner"; void inner_f1(){ System.out.println(this.str); System.out.println(new Outer().str); } } public static void main(String[] args){ Outer out=new Outer(); Outer.Inner inner=out.new Inner(); inner.inner_f1(); } }
注意问题:
1:Outer out=new Outer(); Outer.Inner inner=out.new Inner(); 实例化一个内部类;
No enclosing instance of type Outer is accessible. Must qualify the allocation with an enclosing instance of type Outer (e.g. x.new A() where x is an instance of Outer).
2:System.out.println(this.str); System.out.println(new Outer().str);
第三题:
public class C extends B implements A { public void pX(){ System.out.println(super.str); System.out.println(A.str); } public static void main(String[] args) { new C().pX(); } }
注意问题:
1:调用父类,用super;
2:调用接口,不需要instantiate;The static field A.str should be accessed in a static way;
第四题:
class A;
package test; class A { String s; A(String s) { this.s=s; } public void print(){ System.out.println(s); } }
Class Testt;
报错:
1)Implicit(不明确的) super constructor A() is undefined for default constructor. Must define an explicit (明确的)constructor;
2)如果删除A类中的构造方法,这个程序可以通过编译但是由于S没有赋值输出的结果为null;
修改:
package test; public class Testt extends A { Testt(String s) { super(s); // TODO Auto-generated constructor stub } public static void main(String[] args) { Testt t=new Testt("s"); t.print(); } }
注意:
1)此处是含参数的构造器constructor;
第五题;
package test; public class TestB extends TestA { public void start(){ System.out.println("TestB"); } public static void main(String[] args) { ((TestA)new TestB()).start(); } }
无报错,可以通过编译;
输出结果为:
TestB
1) override
第六题:有关继承的关系;
TestA
package test; class TestA { String test="Hello TestA"; public void start(){ System.out.println("TestA"); } }
TestB
package test; public class TestB extends TestA { String test="Hello testB"; public void start(){ System.out.println(super.test); System.out.println("TestB"); System.out.println(test); } public static void main(String[] args) { TestA t= new TestB(); t.start(); System.out.println(t.test); } }
输结果:
Hello TestA TestB Hello testB Hello TestA
1)在主函数中,如何调用父类调用父类的属性和方法;
public static void main(String[] args) { TestA t= new TestA(); t.start(); System.out.println(t.test); }
输出结果:
TestA
Hello TestA
2)在主函数中,如何通过子类调用父类的属性,同时又可以调用子类的属性和方法;
public static void main(String[] args) { TestA t= new TestB(); t.start(); System.out.println(t.test); }
输出结果:
Hello TestA
TestB
Hello testB
Hello TestA
3)在主函数中,如果子类overide父类的方法,那么父类的方法还可以被子类调用吗?
在2)中我们用父类实例了一个对象t,结构调用start()的方法时,却是调用子类的方法。
Parent;
package test; class Parent { public Parent() { System.out.println("Parent_constructor"); test(); } public void test() { System.out.println("Parent_test"); } }
Child;
package test; public class Child extends Parent { private String name = "张三丰"; public Child() { super(); this.test(); System.out.println("Child_constructor"); } public void test() { System.out.println("Child_test,name=" + name); } public static void main(String[] args) { new Child(); } }
输出结果;
Parent_constructor
Child_test,name=null
Child_test,name=张三丰
Child_constructor
总结:
1:当父类不含有construtor;
a.子类没有override父类的方法
子类实例化对象可以直接调用父类的方法和属性;如果属性父类和子类有相同的属性,在调用父类的属性时,通过Parent p=new Child();可以获取parent的属性...
package test; class Parent { public void test1() { System.out.println("Parent_test"); } }
package test; public class Child extends Parent { private String name = "张三丰"; public void test() { System.out.println("Child_test,name=" + name); } public static void main(String[] args) { Child t=new Child(); t.test(); t.test1(); System.out.println(t.name); } }
如果属性父类和子类有相同的属性,在调用父类的属性时,通过Parent p=new Child();可以获取parent的属性...
package test; class Parent { String name="张二疯"; public void test1() { System.out.println("Parent_test"); } }
package test; public class Child extends Parent { private String name = "张三丰"; public void test() { System.out.println("Child_test,name=" + name); } public static void main(String[] args) { Child c=new Child(); Parent p=new Child(); p.test1(); System.out.println(c.name); System.out.println(p.name); } }
b.子类overrride父类的方法
无论是通过子类实例化 还是父类通过子类实例化,因为父类的方法被子类override所以输出的结果都是一样;
package test; class Parent { String name="张二疯"; public void test() { System.out.println("Parent_test"); } }
package test; public class Child extends Parent { private String name = "张三丰"; public void test() { System.out.println("Child_test,name=" + name); } public static void main(String[] args) { Child c=new Child(); Parent p=new Child(); c.test(); p.test(); System.out.println(c.name); System.out.println(p.name); } }
输出:
Child_test,name=张三丰
Child_test,name=张三丰
张三丰
张二疯
2:当父类含有不含参数的construtor;
子类的默认的construtor;继承了父类的construtor;
package test; class Parent { public Parent() { System.out.println("Parent_constructor"); test(); } public void test() { System.out.println("Parent_test"); } }
package test; public class Child extends Parent { private String name = "张三丰"; public void test() { System.out.println("Child_test,name=" + name); } public static void main(String[] args) { new Child(); } }
package test; public class Child extends Parent { private String name = "张三丰"; public Child() { super(); } public void test() { System.out.println("Child_test,name=" + name); } public static void main(String[] args) { new Child(); } }
输出结果:
Parent_constructor
Child_test,name=null
2:当父类含有含参数的construtor;
在子类中必须声明一个含参数的construtor,并super()继承,如第四题。
第七题:
父类:
class ExamSuperA { int m = 0; int n = 0; long f(){ return m+n; } }
子类:
class B extends ExamSuperA{ int m=1,n=1; long f(){ long result = 0; super.m=10; super.n=20; result = super.f()+(m+n); return result; } long g(){ long result = 0; result = super.f()+(m+n); System.out.println(super.m); return result/2; } } public class ExamSuper { public static void main(String[] args) { B b = new B(); b.m =3; b.n = 7; long resultOne = b.g(); long resultTwo = b.f(); long resultThree = b.g(); System.out.println("resultOne="+resultOne); System.out.println("resultTwo="+resultTwo); System.out.println("resultThree="+resultThree); } }
输出结果:
0
10
resultOne=5
resultTwo=40
resultThree=20
总结:
通过子类实例化 b
执行long resultOne = b.g(); super.m=0 所以输出的第一个结果为“0”;
执行long resultTwo = b.f();由于子类override父类的,所以此时调用的f()方法是子类的,子类f()方法中又将super.m;和super.n重新赋值;
执行long resultOne = b.g();其中调用的Super.f()中m.n属性的值已经通过子类修改,所以super.f()的值也发生了改变...
特别注意:super.f()中的属性被修改了 区别于:为什么在Operate这个方法中运行后,X的值改变,但Y没有?
Child c=new Child();
Parent p=new Child();
对象c不仅有自己属性和方法,还继承了父类的方法和属性;
如果子类将父类的方法override了,那么用对象c调用的方法为Child 类的方法;p的方法也将被子类的方法override了,也就是说p的方法被override了,原来的方法不存在了。
如果子类将父类的属性同名,可以通过p来调用parent的同名属性。