java（二）

javadoc工具（提取文档注释，说白了就是做程序说明书的）

/**               
需求：建立一个用于操作数组的工具类，其中包含着常见的对数组操作的函数，如：最值，排序等。
@author 郭昭
@version V1.0（版本）
*/
//（/**开始   */结束，这种是文档注释，javadoc可以提取，  javadoc不提取多行注释/*   */。）

class ArrayTool
{
private ArrayTool(){}                         //该类中的方法都是静态的，不需要创建对象，为了保证不让其他程序创建
                             该类对象，可以将构造函数私有化。

/**
  获取整形数组的最大值。
@param（参数）  arr                     接受一个元素为int类型的数组
@return                                              该数组最大的元素值
*/
public static int getMax(int[] arr)
{
int maxIndex=0;
for(int x=1;x<arr.length;x++)
{
if(arr[x]>arr[maxIndex])
maxIndex=x;
}
return arr[maxIndex];
}


/**
对数组进行排序
@param arr                                          接受一个元素为int类型的数组      
*/
public static void selectSort(int[] arr)
{
for(int x=0;x<arr.length-1;x++)
{
for(int y=x+1;y<arr.length;y++)
{
if(arr[x]<arr[y])
swap(arr,x,y);
}
}
}



/**
用于对数组的两个元素进行位置置换
@param temp                                     用于交换位置时记录数值的中间参数
@param a                                            要交换位置的一个元素的角标
@param b                                要交换位置的另一个元素的角标
*/
private static void swap(int[] arr,int a,int b)
{
int temp=arr[a];
arr[a]=arr[b];
arr[b]=temp;
}



/**
获取指定元素在制定数组中的索引
@param arr                                   接受一个元素为int类型的数组
@param key                          要查找的元素
@return                                         返回该元素第一次出现的位置，如果不存在返回-1
*/
pubilc static int getIndex(int[] arr,int key)
{
for(int x=0;x<arr.length;x++)
{
if(arr[x]==key)
return x;
}
return -1;                               //没找到这个数
}




/**
将int数组转换成字符串，格式是：[e1,e2,e3....]
@param arr                                接受一个元素为int类型的数组
@param return                                   返回该数组的字符串表现形式
*/
public static String arrayToString(int[] arr)     
{
String atr=" ";
for(int x=0;x<arr.length;x++)
{
if(x!=arr.length-1)
str=str+arr[x]+",";
else
str=str+arr[x]+"]"
}
return str;
}

}




class ArrayToolDemo
{
public static void main(String[] args)
{
int[] arr={26,9,63,3,15,6,13};
/* ArrayTool haha=new ArrayTool();                                    方法中并没有访问特有数据，所以创建这个对象是多余的。
                                                                       把方法都携程静态的就好。
        */
int max=ArrayTool.getmax(arr);
int index=ArrayTool.getIndex(arr,10);                                //这两句也不用对象名调用了，直接用类名调用即可。
System.out.println("max="+max);
System.out.println("index="+index);
}


}




设计模式：对问题行之有效的解决方式，其实就是一种思想。
比如盖一栋欧式的楼，需要哪些材料，如果每次都在要盖时才慢慢想，效率很低，而且一旦出错损失很大，把这些
盖欧式楼的必须材料总结在一起，下次直接拿来用，效率就会提高很多。这就是设计模式的思想。


1.单例设计模式
解决的问题：就是可以保证一个类在内存中的对象唯一性。
  比如多个程序使用同一个配置信息对象时，就需要保证对象的唯一性。如何保证对象唯一性呢？
1.不允许其他程序用new创建该类对象。
2.在该类中创建一个本类实例。
3.对外提供一个方法让其他程序可以获取该对象。
步骤：
1.私有化该类构造函数。
2.通过new在本类中创建一个本类对象。
3.定义一个公有方法，将创建的对象返回。


class Single
{
private static Single s=new Single();
private single(){}
public static Single getInstance()         //主函数调用该方法时，只能通过对象或者类名调用，类名调用必须是静态的，
  //所以该方法要加static，该方法返回值是s，静态方法只能返回静态值，所以s要加static
{
return s;
}
}
class SingleDemo
{
public static void main(String[] args)
{
Single ss=Single.getInstance();
                //       Single ss=Single.s          不这样写，因为这样不可控。
}
}






延迟加载形式：(上面的形式类一加载就创建了对象，而这种延迟加载形式调用Instance时才会创建对象。)
class Single
{
private static Single s=null;
private single(){}
public static Single getInstance()           
{
if(s==null)
s=new Single();
return s;
}
}

extends（继承）
继承：子类共性向上抽取形成父类（基类），子类和父类的关系就是继承。
优点：1.继承提高了代码的复用性，多个类相同的成员可以放到同一个类中。

    2.提高了代码的维护性，如果功能的代码需要修改，修改一处即可。
            3.让类于类之间产生了关系，给第三个特征多态提供了前提。
java中支持单继承（一个子类只有一个直接父类），不支持多继承，但对C++中的多继承机制进行了改良。
不直接支持多继承（可以理解成一个儿子只能有一个父亲），是因为当父类中有相同的成员时，会产生调用的不确定性。
java支持多层继承（可以理解为祖孙三代，四世同堂）。   即c继承b，b继承a。

什么时候使用继承？
答：当类于类之间存在着所属关系时，也就是”is a”的关系，就定义继承。即x是y的一种时，就定义x extends y。

举例：水果，香蕉
举例：水杯，水果 (不能采用继承。)
举例：动物，狗
当要使用一个继承体系时：
1.查看该体系的顶层类，了解该体系的基本功能。
2.创建体系中的最子类，完成功能的使用。

方法重写(子类的方法名，参数和父类完全一样，将父类方法覆盖)：
1.必须存在继承关系
2.父类的方法满足不了你的需求，此时你就需要重写父类的方法，实现自己想要实现的功能

在子父类中，成员的特点体现:
1.成员变量
2.成员函数
3.构造函数

super关键字：
当本类的成员和局部变量同名用this区分，
当子父类的成员变量同名时用super区分。
this和super的用法很相似，
this：代表一个本类对象的引用。
super：代表一个父类空间。

this和super的使用区别?
A:成员变量
this.成员变量   本类的成员变量
super.成员变量 父类的成员变量
B:成员方法
this.成员方法() 本类的成员方法
super.成员方法() 父类的成员方法
子类不能直接访问父类中的私有内容，可以通过方法访问。

继承间的成员方法关系：
A:方法名不同，非常简单
B:方法名相同
首先在子类中找
然后在父类中找
如果还是没有就报错。(不考虑父亲的父亲…)
当子父类中出现成员函数一模一样的情况，会运行子类的函数。
这种现象称为覆盖操作。这是函数在子父类中的特性。     函数的两个特性是重载和覆盖。


什么时候使用覆盖操作？
答：当对一个类进行子类的扩展时，子类需要保留父类的功能声明，但是要定义子类中该功能的特有内容时，就使用覆盖操作。
覆盖注意事项：
1.子类覆盖父类方法时，子类权限必须大于等于父类权限。
2.静态是能覆盖静态，或者被静态覆盖。

子父类中的构造函数的特点：
在子类构造对象时，发现访问子类构造函数时，父类也运行了，为什么呢？
原因是：在子类的构造函数中第一行有一个默认的隐式语句：  super（）；
子类的实例化过程：子类中所有的构造函数默认都会访问父类的空参数的构造函数。
为什么子类实例化的时候要访问父类的构造函数呢？
答：因为子类继承了父类，获取了父类的属性，所以在使用父类内容之前，要先看父类是如何对自己的内容初始化的。
为什么完成这个必须的动作，就在子类的构造函数中加入了super（）语句？
答：如果父类没有定义空参数构造函数，那么子类构造函数必须用super明确要调用父类中的那个构造函数。
    同时子类构造函数如果使用了this调用了本类构造函数时，super就没了。因为super和this都只能定义在第一行，所以只能有一个。
    但是可以保证的是，子类中肯定会有其他的构造函数访问父类的构造函数。
注意：super语句必须要定义在子类构造函数的第一行，因为父类的初始化动作要先完成。

总结：每个子类的构造方法的第一行，有一条默认的语句:
super();

    假如父类没有无参构造方法,该怎么办呢?
调用父类的其他构造方法。带参构造。
怎么访问呢?
super(...)

    建议：
永远给出无参构造方法。

一个对象实例化过程：
Person p=new Person()
1.JVM会读取指定路径下的Person.class文件，加载进内存，并会先加载Person类的父类（如果有的话）。
2.在堆内存开辟空间，分配地址。
3.在对象空间中，对对象的属性进行默认初始化。
4.调用对应的构造函数进行初始化。
5.在构造函数中，第一行会先调用父类中的构造函数进行初始化。
6.父类初始化完毕后，再对子类的属性进行显式初始化。
7.然后再进行子类构造函数的特定初始化。
8.初始化完毕后，将地址值赋给引用变量。