数组工具
1，数组工具对象建立
class ArrayToolDemo
{
/*保证程序的独立运行*/
public static void main(String[] args)
{
int[] arr={4,8,2,9,72,6};
//ArrayTool tool=new ArrayTool();
int max=ArrayTool.getMax(arr);
System.out.println("max="+max);
int index=ArrayTool.getIndex(arr,10);
System.out.println("index="+index);
}
}
2，数组工具类中静态的使用
/**
建立一个用于操作数组的工具类，其中包含着常见的对数组操作的函数如：最值，排序等。
@author 张三
@version V1.0
*/
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（接收数组arr）接收一个元素为int类型的数组
*/
public 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);
}
}
}
/**
用于给数组进行元素位置互换
*/
private static void swap(int[] arr,int a,int b)
{
int temp=arr[a];
arr[a]=arr[b];
arr[b]=temp;
}
/**
获取指定的元素在指定数组中的索引
@param arr（接收数组arr）接收一个元素为int类型的数组
@param key要找的元素
@return 返回该元素第一次出现的位置，如果不存在返回-1
*/
public 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,....]
@param arr（接收数组arr）接收一个元素为int类型的数组
@return 返回该数组的字符串表现形式
*/
public static String arrayToString(int[] arr)
{
String str="[";
for(int x=0;x<arr.length;x++)
{
if(x!=arr.length-1)
str=str+arr[x]+",";
else
str=str+arr[x]+"]";
}
return str;
}
}3，数组工具类--文档注释
单列设计模式
//饿汉式
class Single//类一加载，对象就已经存在
//单列设计模式，保证数据的唯一性
{
static Single s=new Single();
private Single(){}
public static Single getInstance()
{
return s;
}
}
//懒汉式
class Single2//类加载进来没有对象，只有调用了getInstance方法时，才会创建对象
{ //延迟加载形式
private static Single s=null;
private Single(){}
public static Single getInstance()
{
if(s==null)
s=new Single();
return s;
}
}
class SingleDemo
{
public static void main(String[] args)
{
Single s1=Single.getInstance();
Single s2=Single.getInstance();
System.out.println(s1==s2);
}
}概念：对问题行之有效的解决方式，是一种思想
解决的问题：可以保证一个类在内存中的对象唯一性
如何保证唯一性？
- 不允许其他程序用new创建该类对象
- 在该类创建一个本类实例
- 对外提供一个方法让其他程序可以获取该对象
1,饿汉式
class Single类一加载，对象就已经存在
单列设计模式，保证数据的唯一性
2,懒汉式
class Single2类加载进来没有对象，只有调用了getInstance方法时，才会创建对象
延迟加载形式
继承
class Person
{
String name;
int age;
}
class Student extends/*继承*/ Person
{
//String name;
//int age;
void study()
{
System.out.println(name +"...student study...."+age);
}
}
class Worker extends/*继承*/ Person
{
//String name;
//int age;
void work()
{
System.out.println("worker work");
}
}
class ExtendsDemo
{
public static void main(String[] args)
{
Student s=new Student();
s.name="zhangsan";
s.age=20;
s.study();
}
}好处：
- 提高代码的复用性
- 让类与列之间产生关系给第三个特征多态提供了前提
什么时候定义继承？
当类与类之间存在所需关系时定义继承
当子父类中出现成员函数一模一样时，会运行子类函数
这种现象称为覆盖操作。
函数的两个特性：
1，重载。同一个类中，overload
2，覆盖，子类中，覆盖也称为重写，覆写 override
/*
在子父类中，成员的特点体现
1，成员变量
2，成员函数
3，构造函数
*/
//1，成员变量
/*
当本类的成员和局部变量同名用this区分。
当子父类的成员变量同名用super区分父类
this和super的用法很相似
this：代表一个本类对象的引用
super：代表一个父类的空间
*/
class Fu
{
int num1=4;
}
class Zi extends Fu
{
int num2=5;
void show()
{
System.out.println(num2+"......"+num1);
}
}
class ExtendsDemo2
{
public static void main(String[] args)
{
Zi z=new Zi();
z.show();
}
}/*
当子父类中出现成员函数一模一样时，会运行子类函数
这种现象称为覆盖操作。
函数的两个特性：
1，重载。同一个类中，overload
2，覆盖，子类中，覆盖也称为重写，覆写 override
*/
class Fu
{
public void show()
{
System.out.println("fu shou run");
}
}
class Zi extends Fu
{
public void show()
{
System.out.println("zi shou run");
}
}
class ExtendsDemo3
{
public static void main(String[] args)
{
Zi z=new Zi();
z.show();
}
}