案例1.

package cn.itcast.oop;

public class ThisDemo {
	public static void main(String[] args) {
		Student s=new Student();
		s.setName("李卫康");
		s.setAge(22);
		String name=s.getName();
		int age=s.getAge();
		System.out.println("学生的姓名是："+name+"  学生的年龄是："+age);
	}
}
class Student{
	private String name;
	private int age;
	public String getName() {
		return name;//这里默认省略了this,实际上是this.name
	}
	public void setName(String name) {
		name = name;
	}
	public int getAge() {
		return age;
	}
	public void setAge(int age) {
		age = age;
	}
}

这段代码非常简单,可是非常easy出错！出错的关键点就在于this.

执行结果：

为什么会这样呢？为什么打印结果不是-->学生的姓名是:李卫康 学生的年龄是：22

案例2.

package cn.itcast.oop;

public class StudentDemo {
	public static void main(String[] args) {
		Person s=new Person();
	}
}
class Person{
	private String name="林青霞";
	private int age=27;
	public Person(){
		name="刘毅";
		age=30;
	}
		
}

A:把Student.class文件载入到内存

B:在栈内存中给s变量开辟一个空间

C:在堆内存中为人类对象申请一个空间

D:给成员便令进行默认初始化.null 0

E:给成员变量进行显示 初始化。林青霞，27

F:通过构造方法给成员变量进行初始化 刘毅。30

G:数据初始化完成,然后把堆内存的地址值赋值给栈内存的s变量
3.继承概述

A:java仅仅支持类的单继承不支持类的多继承

B:子类仅仅能继承父类全部非私有的成员(成员方法和成员变量)
C:子类不能继承父类的构造方法，可是能够通过super(立即讲)keyword去訪问父类构造方法。

D:子类中的成员变量和父类中的成员变量名称一样，
在子类方法中訪问一个变量的查找顺序：

a:在子类方法的局部范围找，有就使用 

b:在子类的成员范围找，有就使用 

c:在父类的成员范围找，有就使用 

d:假设还找不到。就报错。

E:this代表本类相应的引用。super代表父类存储空间的标识(能够理解为父类引用,能够操作父类的成员)

F:继承中构造方法的关系
子类中全部的构造方法默认都会訪问父类中空參数的构造方法:由于子类会继承父类中的数据，可能还会使用父类的数据。所以，子类初始化之前，一定要先完毕父类数据的初始化。

注意：子类每个构造方法的第一条语句默认都是：super();

G:假设父类没有无參构造方法，那么子类的构造方法会出现什么现象呢?报错。
怎样解决呢?

1):在父类中加一个无參构造方法

2):通过使用superkeyword去显示的调用父类的带參构造方法

3):子类通过this去调用本类的其它构造方法,子类中一定要有一个去訪问了父类的构造方法，否则父类数据就没有初始化。

注意事项：
this(...)或者super(...)必须出如今第一条语句上。
假设不是放在第一条语句上，就可能对父类的数据进行了多次初始化，所以必须放在第一条语句上。

H:继承中成员方法的关系:1):子类中的方法和父类中的方法声明不一样，这个太简单。2):子类中的方法和父类中的方法声明一样，这个该怎么玩呢?

通过子类对象调用方法：
a:先找子类中。看有没有这种方法，有就使用
b:再看父类中，有没有这种方法。有就使用
c:假设没有就报错。

I:方法重写的注意事项
1):父类中私有方法不能被重写-->由于父类私有方法子类根本就无法继承
2):子类重写父类方法时。訪问权限不能更低-->最好就一致
3):父类静态方法，子类也必须通过静态方法进行重写
事实上这个算不上方法重写。可是现象确实如此，至于为什么算不上方法重写，多态中我会讲

子类重写父类方法的时候，最好声明一模一样。

例题：

class Fu {
	static {
		System.out.println("静态代码块Fu");
	}

	{
		System.out.println("构造代码块Fu");
	}

	public Fu() {
		System.out.println("构造方法Fu");
	}
}

class Zi extends Fu {
	static {
		System.out.println("静态代码块Zi");
	}

	{
		System.out.println("构造代码块Zi");
	}

	public Zi() {
		System.out.println("构造方法Zi");
	}
}

class ExtendsTest2 {
	public static void main(String[] args) {
		Zi z = new Zi();
		Zi z2 = new Zi();
	}
}

看程序写结果：
A:一个类的静态代码块,构造代码块,构造方法的运行流程
静态代码块 > 构造代码块 > 构造方法
B:静态的内容是随着类的载入而载入
静态代码块的内容会优先运行
C:子类初始化之前先会进行父类的初始化
结果是：
静态代码块Fu
静态代码块Zi
构造代码块Fu
构造方法Fu
构造代码块Zi
构造方法Zi

经典面试题：

class X {
	
	X() {
		System.out.print("X");
	}
	Y b = new Y();
}

class Y {
	Y() {
		System.out.print("Y");
	}
}

public class Z extends X {
	
	Z() {
		//super
		System.out.print("Z");
	}
	Y y = new Y();
	public static void main(String[] args) {
		new Z(); 
	}
}

因此运行流程为：依据初始化的顺序：先默认初始化,显示初始化，构造初始化

1.先初始化父类class X：运行成员变量显示初始化Y y=new Y();因此调用Y的构造函数打印Y

2.父类的构造方法初始化,运行构造方法中的代码打印X

3.子类进行初始化Class Z：运行成员变量初始化Y y=new Y()因此调用Y的构造方法打印Y

4.子类的构造方法初始化：运行构造方法中的代码打印Z

结果为：YXYZ
debug模式：

案例：

package cn.itcast.extend;

public class Demo {
	public static void main(String[] args) {
		Zi z=new Zi();
		z.show();
	}
}
class Fu{
	int num=10;
	public void show(){
		System.out.println(num);
	}
}
class Zi extends Fu{
	int num=20;
	public void show(){
		System.out.println(num);
	}
}

去掉子类的show方法

package cn.itcast.extend;

public class Demo {
	public static void main(String[] args) {
		Zi z=new Zi();
		z.show();
	}
}
class Fu{
	int num=10;
	public void show(){
		System.out.println(num);
	}
}
class Zi extends Fu{
	int num=20;
}

为什么呢：由于子类中找方法show（）没有找到就去父类中找.