（笔记）关于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的同名属性。