有多个对象都要用到同一个功能或者多个功能，那就先定义一个工具类，之后调用
class ArrayTool
{
public int getMax(int[] arr){
int max=0;
for(int x=1;x<arr.length;x++)
{
if(arr[x]>arr[max])
max=x;
}
return arr[max];
}
public int getMin(int[] arr){
int min=0;
for(int x=1;x<arr.length;x++)
{
if(arr[x]<arr[min])
min=x;
}
return arr[min];
}
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);
}
}
}
public void bubbleSort(int []arr)
{
for(int x=0;x<arr.length-1;x++)
{
for(int y=0;y<arr.length-x-1;y++)
{
if (arr[y] > arr[y+1])
swap(arr,y,y+1);
}
}
}
public void swap(int []arr,int a,int b)
{
int temp=arr[a];
arr[a]=arr[b];
arr[b]=temp;
}
}
public class hello {
public static void main(String[] args)
{
int[] arr={3,4,1,8};
ArrayTool tool=new ArrayTool();
int max=tool.getMax(arr);
System.out.println("max="+max);
}
}
虽然可以通过建立ArrayTool这个对象对数组调用批量工具对数组进行操作，但是发现了问题
1.对象是用于封装数据的，可是ArrayTool对象并未封装持有数据
2.操作诗句的每一个方法都没有用到ArrayTool对象中的特有数据
这时就考虑，不需要对象
可以将ArrayTool 中的所有方法都定义为静态的，直接通过类名调用
但是还可以将其new对象，通过构造对象私有化，阻止建立对象,还有swap这样的函数不需要暴露给外界
class ArrayTool
{
private ArrayTool(){}
public static int getMax(int[] arr){
int max=0;
for(int x=1;x<arr.length;x++)
{
if(arr[x]>arr[max])
max=x;
}
return arr[max];
}
public static int getMin(int[] arr){
int min=0;
for(int x=1;x<arr.length;x++)
{
if(arr[x]<arr[min])
min=x;
}
return arr[min];
}
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);
}
}
}
public static void bubbleSort(int []arr)
{
for(int x=0;x<arr.length-1;x++)
{
for(int y=0;y<arr.length-x-1;y++)
{
if (arr[y] > arr[y+1])
swap(arr,y,y+1);
}
}
}
private static void swap(int []arr,int a,int b)
{
int temp=arr[a];
arr[a]=arr[b];
arr[b]=temp;
}
}
public class ArrayToolDemo {
public static void main(String[] args)
{
int[] arr={3,4,1,8};
int max=ArrayTool.getMax(arr);
System.out.println("max="+max);
}
}
一个类中默认会有一个空参数的构造函数；
这个默认的构造函数的权限和所属类一致（public or no）；
如果类被public 修饰，那么默认的构造函数也带public修饰符；
如果类没有被public修饰，那么默认的构造函数也没有public修饰。
执行顺序
Person p=new Person(参数);
类加载，静态代码块加载，开辟空间，地址赋给对象p，属性（非静态）加载，默认初始化，显示初始化（直接赋值），构造代码块加载，构造函数初始化
单例设计模式：解决一个类在内存只存在一个对象
A程序修改了一个文件要用到一个对象，B程序也要修改这个文件，不能再new一个对象
要保证对象唯一
1.为避免其他程序过多建立该类的对象，先禁止其他程序建立该类对象
2.为了保证使用对象，只好在本类中自定一个对象
3.为了方便其他程序对自定义对象的访问，可以对外提供一些访问方式
这三步用代码体现
1.构造函数私有化
2.在类中创建一个本类对象
3.提供一个方法可以获取到该对象
class Single{
private Single(){}
private static Single s=new Single();
public static Single getInstance()//此时没有对象，必须静态
{
return s;
}
}
class SingleDemo
{
public static void main(String[] args)
{
Single ss=Single.getInstance();
}
}
下面是两种初始化方式
class Single{
private Single(){}
private static Single s=new Single();
public static Single getInstance()//此时没有对象，必须静态
{
return s;
}
}
class Single1{
private static Single1 s=null;
private Single1(){}
public static Single1 getInstance()//此时没有对象，必须静态
{
if(s==null)
s=new Single1();
return s;
}
第一种是光初始化对象，成为饿汉式
single类一进内存，就建立对象
第二种是方法被调用时，才初始化，对象延时加载，成为懒汉式
single1类进内存还没有建立对象，只有调用方法才建立
但是不特殊处理的话，多线程中会出问题建立两个对象，需要synchronized关键字，类似互斥锁
class Single1{
private static Single1 s=null;
private Single1(){}
public static Single1 getInstance()//此时没有对象，必须静态
{
if(s==null) {
synchronized (Single1.class) {//读锁
if (s == null)
s = new Single1();
}
}
return s;
}