JavaSE 最easy出错的几个简单的问题

案例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;
}

}

Person s=new Person();做了哪些事情

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);
}
}

结果是毋容置疑的：20

去掉子类的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;
}

答案是：10

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