继承；成员变量隐藏与重写；关键字super；final类和final方法

1. 如果一个类的声明中没有使用关键字extends，这个类被系统默认是Object类的子类，Object是包java.lang中的类

2. 子类和父类在同一个包中，子类能继承除了private之外的所有东西，要是不再一个包中，只能继承父类的protected和public的变量和方法，不能继承父类的友好方法和友好变量。

3. 子类的构造方法没有明确的指明要调用父类的哪个构造函数时，就默认为调用了不带参数的构造函数。

4. 子类可以调用继承的方法去操作这些未被子类继承却分配了内存空间的变量，还有父类成员变量隐藏的问题：

class A
{
	private int x = 10;//private变量
	protected int y = 20;
	public int z = 100;//父类成员变量z
	void f()
	{
		y = y + x;//包含private变量x
		System.out.printf("x = %d, y = %d", x, y);
	}
}

class B extends A
{
	int z = 300;//子类重新定义与父类中相同的成员变量（名字相同，类型可以不同）时，子类就隐藏了父类的该成员变量
	int p()
	{
		z = z + 1;
		System.out.printf("z = %d\n", z);
		return z;
	}
	void g()
	{
		y = y + 1;
	}
}

public class test5
{
	public static void main(String args[])
	{
		B b = new B();
		b.p();//查看变量的隐藏
		b.g();//调用子类自己声明的方法
		b.f();//调用从父类继承来的方法， 在这个方法里可以访问到private类型的变量x
		b.g();//调用子类自己的声明的方法
	}
}


输出：



z = 301
x = 10, y = 31

5. 方法重写的问题：
//方法的重写：子类中定义一个方法，并且这个方法的名字，返回类型，参数个数和类型与从父类继承来的方法完全相同，
//子类通过方法的重写可以隐藏继承的方法，可以把父类的状态和行为改变为子类自己的状态和行为

class C
{
	public int y = 20;//父类中定义的变量y
	void f()
	{
		y = y + 1;
		System.out.printf("y = %d", y);
	}
}

class D extends C
{
	
	int z = 300;//子类中新定义的变量z
	
	void f()
	{
		y = y + z;//重写的方法既可以操作继承的成员变量，也可以操作子类声明定义的成员变量
		System.out.printf("y = %d",y);
	}
}

public class test6
{
	public static void main(String args[])
	{
		D d = new D();
		d.f();//调用重写的方法
	}
}

输出：
y = 320

6。 super关键字：
//方法的重写：子类中定义一个方法，并且这个方法的名字，返回类型，参数个数和类型与从父类继承来的方法完全相同，
//子类通过方法的重写可以隐藏继承的方法，可以把父类的状态和行为改变为子类自己的状态和行为
//关键字super有两种用法：一种是子类使用super调用父类的构造方法，另一种是子类使用super调用被子类隐藏的成员变量和方法

class C
{
	public int y = 20;//父类中定义的变量y
	void f()
	{
		y = y + 1;
		System.out.printf("这是父类中的f（）：y = %d", y);
	}
}

class D extends C
{
	int z = 300;//子类中新定义的变量z
	int y  = 100;
	void f()//重写方法
	{
		int c = super.y;
		System.out.printf("这时父类中y的值：super c = %d\n", c);//父类成员变量被隐藏之后，通过super调用父类中的变量
		y = y + z;//重写的方法既可以操作继承的成员变量，也可以操作子类声明定义的成员变量
		int m = y + super.y;//子类中新定义的y和父类中继承的y
		System.out.printf("子类中最终的 y = %d;父类中的y为 super.y = %d; 子类y和父类y之和：m = %d \n",y, super.y, m);
	}
	void s()
	{
		super.f();//在父类方法隐藏之后，通过super调用父类中的方法
	}
}

public class test6
{
	public static void main(String args[])
	{
		D d = new D();
		d.f();//调用重写的方法以及通过super调用父类中的变量
		d.s();//通过super调用父类中的方法
	}
}


输出：

这时父类中y的值：super c = 20
子类中最终的 y = 400;父类中的y为 super.y = 20; 子类y和父类y之和：m = 420 
这是父类中的f（）：y = 21

7. final类和final方法：
final类不能被继承，没有子类；
final方法不能被子类重写。