制作帮助文档、利用api文档学习工具类使用、代码块、继承及继承的注意点

帮助文档的制作
从一个例子开始
class ArrayDemo{
public static void main(String[] args){
int[] arr = {28,55,37,46,19};
printArray(arr);
}

public static void printArray(int[] arr){
for(int i=0;i<arr.length;i++){
if(i==arr.length-1){
System.out.println(arr[i]);
}else{
System.out.print(arr[i]+", ");
}
}
}
}
注意这里printArray方法也定义为static静态，这里我们很自然的就写为静态的了，之前也写过
类似的方法，通过上一篇的知识我们知道，这是因为main方法也是静态的，而静态方法只能调用静态
方法，静态的方法和变量在非静态的方法和变量之前加载(非静态方法随着对象的生成而生成，意味着
如果要调用非静态的方法或者变量只能通过创建对象来调用)，如果调用一个非静态方法会报错了，
因为在静态方法已经加载完成的时候，非静态方法还没有加载的。
所以如果要将printArray写成非静态方法，又想调用它的话，只能写成如下形式
class ArrayDemo{
public static void main(String[] args){
int[] arr = {28,55,37,46,19};
//printArray(arr); 在静态方法main中不能非静态方法
ArratDemo ad = new  ArratDemo();
ad.printArray(arr);
}

public  void printArray(int[] arr){
for(int i=0;i<arr.length;i++){
if(i==arr.length-1){
System.out.println(arr[i]);
}else{
System.out.print(arr[i]+", ");
}
}
}
}


但是按照面向对象的思想，这个printArray方法是用于数组的（输出数组的元素），那么这个方法不应该写在ArrayDemo
类中，而是应该写在一个专门用于提供数组方法的类中，所以我们可以新建一个java文件,创建一个ArrayTool类，用于编写
提供数组工具方法。
小疑问：写在另外一个文件下类，在这个文件下ArrayDemo中的main方法也可以调用到吗？
在这里要顺带提下，只要是在一个文件夹中java文件，多个类写在一个文件下跟写在不同文件下的效果是一样的，因为javac编译之后
都会在当前文件夹下生成.class文件，如果是写在一个文件下的多个类，那么编译的时候也会一同将所有相关的类编译成.class文件，
如果是写在一个文件下的多个类，那么编译的时候也会一同将所有相关的类编译成class文件，所以效果是一样的。


当然我们这里要讨论的重点是static静态修饰符，作为工具类，我们应该将里面的工具方法定义为静态，这样就可以通过类名调用了
但是有个问题，我们还是可以通过对象调用静态方法，这样的话感觉非静态方法没什么特别的，所以我们需要将”构造方法私有化“
class ArrayDemo{
public static void main(String[] args){
int[] arr = {28,55,37,46,19};
//ArratTool at = new ArrayTool();
//at.printArray(arr);
ArrayTool.printArray(arr);
}
}


class ArrayTool{
private ArrayTool(){};

public static void printArray(int[] arr){
for(int i=0;i<arr.length;i++){
if(i==arr.length-1){
System.out.println(arr[i]);
}else{
System.out.print(arr[i]+", ");
}
}
}
}


这样的话我们就不可以通过new的方式创建ArrayTool的对象，这个ArrayTool就仅仅是一个工具类了。


说明文档：
说明文档是chm文件，这个文件是由html文件转换而来的，一般我们自己通过javadoc生成的文档都是
多个html文件打包成的文件夹
java.lang下的包不需要导入，除此之外的都是需要导入，比如java.util.Scanner


如何使用帮助文档：
1:打开帮助文档
2:点击显示，找到索引，看到输入框
3:知道你要找谁?以Scanner举例
4:在输入框里面输入Scanner，然后回车
5:看包
java.lang包下的类不需要导入，其他的全部需要导入。

要导入：
java.util.Scanner
6:再简单的看看类的解释和说明，别忘了看看该类的版本
7:看类的结构
成员变量 字段摘要
构造方法 构造方法摘要 
成员方法 方法摘要
8:学习构造方法
A:有构造方法 就创建对象
B:没有构造方法 成员可能都是静态的
9:看成员方法
A:左边
是否静态：如果静态，可以通过类名调用
返回值类型：人家返回什么，你就用什么接收。
B:右边
看方法名：方法名称不要写错
参数列表：人家要什么，你就给什么；人家要几个，你就给几个

利用帮助文档掌握Math类的使用，先掌握生成随机数的方法


代码块：
1.局部代码块
处于局部位置，即方法定义中，用于限定变量的生命周期
public static void main(String[] args){
{
局部代码块语句;
}
}
2.构造代码块
class C{
//成员位置
{
语句;
}
}
在构造方法的位置，类中成员的位置,在new对象的时候会先执行构造代码块中的语句,之后再执行构造防范
因为构造代码块是属于“类”的一部分，不同于普通的成员变量和方法是属于“对象”的一部分，所以
在类加载的时候，构造代码块也跟着一块加载并执行了。
作用：可以把多个构造方法中的共同部分放到构造代码块中
3.静态代码块
在类中成员位置，只不过用static修饰
class C{
//成员位置
static{

}
}
和构造代码块较为类似，不过比构造代码块更早执行，而且只会执行一次。
作用：一般用于对“类”进行初始化，而构造方法和构造代码块是对“对象”进行初始化


执行顺序
静态代码块------》 构造代码块 -----》构造方法
只执行一次       




继承:
extends继承
class child extends father{}
提高代码复用性、维护性、让类与类产生了关联，是多态的前提
类与类之间的关系，其实也是继承的一个弊端:
类的耦合性增强了，比如说多个继承了同一个类的子类，如果某个类想要改变一个方法的实现（这个方法是共同的方法）
那么要改变的话，其他的子类也会被迫跟着改变。而在实际开发中，多个类应该要朝着低耦合，高内聚的方向发展


继承的特点:
只支持单继承，不能多继承 class C extends A,B 这是不可以的！
但是支持多层继承  class C extends B{}; class B extends A{};父类又继承其他的
只能继承父类所有“非私有”成员（成员变量和成员方法）
子类不能继承父类的构造方法（即便不是私有的），但是可以通过super去访问父类的构造方法


疑问或者注意点：
1.子类不能继承父类的私有成员，如果父类有个公共方法去访问父类的成员变量，通过子类的继承的
这个方法之后，子类也可以访问这个父类的私有成员变量（这点其实感觉很奇怪）
2.当子类的成员变量的名称一样，会怎么样？
答：首先，这种写法是允许的，在实际使用的时候，调用变量的时候采取就近原则
实际调用的时候，按照
子类局部范围-子类成员范围-父类成员范围
的顺序查找。
但是如果在这3个范围有名称相同的3个变量，还仍然想在子类的局部范围（即子类的非静态成员方法）内访问的话
其实也是可以的，访问子类自身的成员变量，前面已经说过用this.成员变量名
访问父类的成员变量，用super.父类成员变量名 即可。


this super关键字
通过这2个关键字可以调用奔雷和父类的构造方法已经成员方法和成员变量
this();super() 调用构造方法
this.成员变量或方法/super.成员变量或方法


子类的所有构造方法默认都会访问父类的无参构造方法，即：子类的每一个构造方法系统都会默认给其第一句加上
super();,所以！有两种方法
A.给父类（或者说有子类的类）加上无参构造方法！因为子类会继承父类的数据，所以在使用子类之前要
先初始化父类。
B.在子类的构造方法中显示的调用父类的带参构造方法


另外注意，如果要显示的调用父类的构造方法，super最好写在第一行，因为如果没放在第一行，那么系统仍然会
给第一行语句默认加上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(); 
}
}


答案：
YXYZ
执行顺序：
new Z();进行Z类的初始化，但是由于继承了X类，所以先进行X类的初始化
X的初始化会先对构造代码块或者成员变量进行初始化，于是执行 new Y()然后再执行X()构造方法，输出YZ
再进行子类Z的初始化，而Z的初始化会初始化成员变量或构造代码块即 Y y = new Y();之后再执行构造方法
于是接着输出 YZ，所以结果是YXYZ


方法重写：
引入：
继承中子父类的成员方法的关系：
当子类和父类中成员方法声明一样的时候，同成员变量类似，也是取得就近原则，先在子类中查找，如果有这个方法
如果没有就去父类中找，如果子父类中都没有就报错。
方法重写的概念：
如果子类中出现了和父类中方法声明一模一样的方法，所谓方法声明一样就是指 方法名和参数列表“以及返回值类型”都一样
而方法重载仅仅只是指方法名一样，而参数列表不同，而且方法重载与返回值类型无关！
当实际调用的时候，会使用当前调用的这个类的方法。
比如说
//定义一个人类，人类有个行为叫做 工作
class Person{
public void work(){
System.out.print("工作:");
}
}
//老师继承于人类，但是工作的内容不一样，老师的工作是教书
class Teacher extends Person{
public void work(){
super.work();
System.out.println("教书");
}
}
//学生也继承于人类，但是学生的工作是 学习
class Teacher extends Person{
public void work(){
super.work();
System.out.println("学习");
}
}


class ChongxieDemo{
public static void main(String[] args){
Student s = new Student();
s.work();
}
}
这样子类的方法就可以在重写父类的同名方法的功能的基础之上再去写自己的方法了。


注意：
1.父类的私有方法不能被重写：
其实这是个面试题，实际上父类的私有根本就不存在被重写这种概念，因为父类的私有方法对子类
完全是隐蔽的，子类根本拿不到，所以也就不存在重写了
2.方法重写时的访问权限：
之前说过几种权限修饰符：
public 默认（什么也不写） private
这几种，其中public的权限是最高的
在方法重写的时候，子类的同名方法的访问必须大于等于父类才可以
3.父类的静态方法，子类也必须通过静态方法才可以重写（其实这个严格意义上来说，根本就算不上是重写）


总之记住一句：子类重写父类方法的，最好是方法声明部分一模一样。


英文翻译：
override:方法重写
overload:方法重载


以猫狗类的例子来熟悉一遍java中的继承
猫：年龄 颜色
捉迷藏 吃东西
狗 年龄 颜色
看门 吃东西
//将公共部分定义到animal动物类中:
class Animal{
private int age;
private String color;

//构造方法
public Animal(int age,String color){
this.age = age;
this.color = color;
}

public Animal(){
}

public void setAge(int age){
this.age = age;
}
public void setColor(String color){
this.color = color;
}
public int getAge(){
return this.age;
}
public String getColor(){
return this.color;
}



public void eat(){
System.out.println("吃东西");
}
}
//定义Dog类
class Dog extends Animal{
public Dog(){
}

public Dog(int age,String color){
super(age,color);
}

public void lookDoor(){
System.out.println("看门");
}
}


class AnimalDemo{
public static void main(String[] args){
Dog dog = new Dog(10,"blue");
System.out.println(dog.getAge()+"----"+dog.getColor());
dog.eat();
dog.lookDoor();

Dog dog2 = new Dog();
dog.setAge(9);
dog.setColor("black");
System.out.println(dog.getAge()+"----"+dog.getColor());
dog.eat();
dog.lookDoor();
}
}