Java入门day08(帮助文档、代码块、继承)

1.如何制作帮助文档

个人理解：写一个功能类，然后对其解释说明 注意该功能类必须用public修饰，否则会报错

​ 如class ArrayTools

​ javadoc: 错误 - 找不到可以文档化的公共或受保护的类。

工具使用格式：javadoc -d 目录 -auther -version 功能类名.java

注意：

1.目录就是生成文档存放的路径（会自动生成）

2.功能类必须用public修饰，否则没有访问权限

3.有参数的方法必须使用@param来注释（否则会有警告）

4.有返回值的方法必须使用@return来注释（否则会有警告）

5.加入-encoding utf-8 可以解决中文乱码问题

2.通过JDK提供的API学习Math类

1.API application programming interface(应用程序编程接口) （帮助文档）

2.如何使用？

​ 看字段、构造方法、成员方法

3.Math类

​ A:是针对数学进行操作的类
​ B:没有构造方法,因为它的成员都是静态的
​ C:产生随机数
​ public static double random() : 该方法产生的数范围[0.0,1.0)
​ D:如何产生一个1-100之间的随机数
​ int num = (int)(Math.random()*100)+1 ;
​ E:猜数字小游戏

public static void main(String[] args) {
    Scanner sc = new Scanner(System.in);
    System.out.println("请输入一个0-100的整数");
    while (true) {
        int x = sc.nextInt();
        if (x == 23) {
            System.out.println("right");
            break;
        } else if (x > 23){
            System.out.println("猜大了,请继续输入");
        }else{
            System.out.println("猜小了,请继续输入");
        }
    }
}

3.代码块

​ 代码块：在Java中，使用**{}**括起来的代码被称为代码块，根据其位置和声明的不同，可以分为局部代码块，构造代码块，静态代码块，同步代码块（多线程讲解）。

（1）用{ }括起来的代码

（2）分类：

​ A:局部代码块 方法中

​ 用于限定变量的生命周期，及早释放，提高内存利用率。

​ B:构造代码块 类中

​ 把多个构造方法中相同的代码可以放到这里，每个构造方法执行前，首先执行构造代码块。

​ C:静态代码块 类中

​ 对类的数据进行初始化，仅仅执行一次

​ 在加载的时候就执行，并且只执行一次。Test t;

（3）静态代码块，构造代码块，构造方法的顺序问题

​ 静态代码块>构造代码块>构造方法

4.继承

（1）把多个类中相同的成员给提取出来定义到一个独立的类中。然后让这多个类和该独立的类产生一个关系，这个类就具备了这些内容，这个关系就叫继承。

（2）Java中如何表示继承?

​ A：用关键字extends表示

​ B：格式

​ class 子类名 extends 父类名{ }

(3)继承的好处

​ A：提高了代码的复用性
​ B：提高了代码的维护性
​ C：让类与类产生了一个关系，是多态的前提

(4)继承的弊端

​ A：让类的耦合性增强。

​ B：打破了封装性。

（5）Java中继承的特点

​ A：Java中的类只支持单继承，接口可以多继承

​ B：Java中可以多层（重）继承

(6）继承的注意事项

​ A：子类继承父类所有的成员，只是无法访问到父类的私有成员而已

​ B：子类不能继承父类的构造方法，但是可以通过super去访问

​ C：不要为了部分功能而去继承

（7）Java继承中的成员关系

​ A：成员变量

​ a：子类的成员变量名称和父类中的成员变量名称不一样。

​ b：子类的成员变量名称和父类中的成员变量名称一样。该怎么访问？

​ 子类的方法访问变量的查找顺序：

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

​ 在子类的成员范围找，有就使用。

​ 在父类的成员范围找，有就使用。

​ 找不到，就报错。

​ B：构造方法

​ a：子类的构造方法默认会去访问父类的无参构造方法（第一句默认super( )）

​ 是为了子类访问父类数据的初始化。

​ b：父类中如果没有无参构造方法，该怎么办?

​ 子类通过super去明确调用带参构造

​ 子类通过this调用本身的其它构造，但是一定会有一个去访问了父类的构造

​ 让父类提供无参构造

​ C：成员方法

​ a：子类的成员方法和父类中的成员方法名称不一样

​ b：子类的成员方法和父类中的成员方法名称一样。该怎么访问？

​ 在子类中找，有就使用。

​ 在父类中找，有就使用。

​ 找不到就报错。

​ (8)方法重写的注意事项

​ A：父类的私有方法无法被重写

​ B：子类重写父类方法时，访问权限不能更低

​ C：父类是静态方法，子类也必须通过静态方法进行重写。（其实这个也算不上方法重写，但现象确实如此）

​ (9)两个面试题：
​ A：Override和Overload的区别？Overload是否可以改变返回值类型？

​ 答：Override（重写）：在子类中出现了和父类中方法声明一模一样的方法。[返回值，方法名，参数名一样]

​ Overload(重载)：在同一个类中出现的方法名一样，参数列表不同的现象。与返回值无关。

​ 可以改变

​ B：this和super的区别和各自的作用？

​ this：代表当前类的对象引用

​ super：代表父类存储空间的标识（可以理解为父类的引用）

​ 场景：
​ 成员变量：
this.成员变量
​ super.成员变量
​ 构造方法
​ this(…)
super(…)
成员方法：
this.成员方法
​ super.成员方法

​ (10) 一个类的初始化过程

​ a：先对成员变量进行初始化

​ b： 默认初始化

​ c：显示初始化
d：构造方法初始化

面试题1：一个类的初始化过程
看程序写结果：（知识点）
A．访问变量 就近原则
B．this和super的问题
this访问本类的成员
super访问父类的成员
C．子类构造方法执行前默认先执行父类的无参构造方法
D．一个类的初始化过程
先对成员变量进行初始化
默认初始化
显示初始化
构造方法初始化
结果： Fu
Zi
30
20
10

class Fu {
	public int num = 10;
	public Fu() {
		System.out.println("Fu");
	}
}
class Zi extends Fu {
	public int num =20;
	public Zi() {
		System.out.println("Zi");
	}
	public void show() {
		int num = 30;
		System.out.println(num);
		System.out.println(this.num);
		System.out.println(super.num);
	}
}
class ExtendsDemo2 {
	public static void main(String[] args) {
		Zi z = new Zi(); //输出 Fu 
						 //		Zi
		
		z.show();		 //输出 30
						 // 	20
						 // 	10
	}
}

面试题2：子父类的构造执行过程
看程序写结果： (知识点)
A.一个类的静态代码块，构造代码块，构造方法的执行流程
静态代码块 > 构造代码块 > 构造方法
​ B.静态的内容是随着类的加载而加载
静态代码块的内容会优先执行
​ C. 子类初始化之前会进行父类的初始化

​ 当实例化子类对象时，首先要加载父类的class文件进内存，静态代码块是随着类的创建而执行，所以父类静态代码块最先被执行，子类class文件再被加载，同理静态代码块被先执行；实例化子类对象要先调用父类的构造方法，而调用父类构造方法前会先执行父类的非静态代码块

结果：

静态代码块Fu

静态代码块Zi

构造代码块Fu

构造方法Fu

构造代码块Zi

构造方法Zi

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 ExtendsDemo2 {
	public static void main(String[] args) {
		Zi z = new Zi();
	}
}

面试题3：分层初始化

知识点：

​ A.成员变量的问题
int x = 10;//成员变量是基本类型
Student s = new Student(); //成员变量是引用类型
B.一个类的初始化过程
成员变量的初始化

​ 默认初始化

​ 显示初始化

​ 构造方法初始化

​ C.子父类的初始化（分层初始化）
先进行父类初始化，然后进行子类初始化

​ 结果：

​ YXYZ

问题：虽然子类中构造方法默认有一个super()

​ 初始化的时候，不是按照那个顺序进行的

​ 而是按照分层初始化进行的

​ 它仅仅表示要先初始化父类成员，再初始化子类成员

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

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