（笔记）关于java中的一些问题
第一题：package william;abstract class Name {private String name;public abstract boolean inStupidName(String name){System.out.println("okay");};}
报错：
http://dl.iteye.com/upload/attachment/497541/7fe4b1a5-5506-3b4f-842f-c8d8c876c853.jpg
问题：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;
http://dl.iteye.com/upload/attachment/497615/27b45300-7f4c-3c47-ab04-31c58d63fda3.jpg
报错：
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();}} 无报错，可以通过编译；
输出结果为：
TestB1) 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 TestATestBHello testBHello 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的同名属性。
页:
[1]