Java网课基础笔记（5）19-07-17

1.如何使用一维数组：

                //方法一：
		int[] arrs1= {1,2,3,4};
		int arrs2[]= {1,2,3,4};
		//方法二：
		//1.声明数组
		int[] arrs3;
		//2.分配内存空间
		arrs3=new int[4];
		//3.赋值
		arrs3[0]=1;arrs3[1]=2;arrs3[2]=3;arrs3[3]=4;
        //方法三：
        int[] arrs4=new int[]{1,2,3,4};
		

2.二维数组的声明和遍历

public static void main(String[] args) {
		// TODO Auto-generated method stub
		//声明方法一：数组里套数组声明并赋值
		int[][] arrs1= {{1,2,3,4},{5,6,7,8}};
		int[][] arrs2= new int[][]{{1,2,3,4},{5,6,7,8}};
		//声明方法二：以2行3列的方式是声明并赋值
		int[][] arrs3=new int[2][4];
		arrs3[0][0]=1;
		arrs3[0][1]=2;
		arrs3[0][2]=3;
		arrs3[0][3]=4;
		arrs3[1][0]=5;
		arrs3[1][1]=6;
		arrs3[1][2]=7;
		arrs3[1][3]=8;
		//遍历：以for for循环来遍历数组
		for (int i=0;i<arrs3.length;i++) {
			for (int j = 0; j < arrs3[i].length; j++) {
				System.out.print("arrs3["+i+"]["+j+"]:"+arrs3[i][j]+"\n");
			}
		}
	}

//输出结果
arrs3[0][0]:1
arrs3[0][1]:2
arrs3[0][2]:3
arrs3[0][3]:4
arrs3[1][0]:5
arrs3[1][1]:6
arrs3[1][2]:7
arrs3[1][3]:8

3.冒泡排序：将一个列表里的两个元素进行比较，并将最小的元素交换到顶部，从最底部的元素开始比较，两个元素中较小的会冒到顶部，而比较大的会沉到底部，该过程重复执行，达到排序效果(从大到小）。（从小到大也可以）

public static void main(String[] args) {
		// TODO Auto-generated method stub
		int[] arrs1= {1,3,4,2,8,5,7,6,3};
		int temp=0;//定义一个中间值用于交换
		//定义循环排序次数为arrs.length-1(因为10个数，两两相比，要比10-1次）
		for (int i=0;i<arrs1.length-1;i++) {
			//内部循环代表每次拿一个值向后比较，需要比较arrs.length-1-i次
			for (int j = 0; j < arrs1.length-1-i; j++) {
				//向后比较，只要大于就交换，循环一次完毕导致最大到数排在最后
				if(arrs1[j]>arrs1[j+1]) {
					//交换过程
					temp=arrs1[j];
					arrs1[j]=arrs1[j+1];
					arrs1[j+1]=temp;
				}
			}
			System.out.println(Arrays.toString(arrs1));
		}
	}

[1, 3, 2, 4, 5, 7, 6, 3, 8]
[1, 2, 3, 4, 5, 6, 3, 7, 8]
[1, 2, 3, 4, 5, 3, 6, 7, 8]
[1, 2, 3, 4, 3, 5, 6, 7, 8]
[1, 2, 3, 3, 4, 5, 6, 7, 8]
[1, 2, 3, 3, 4, 5, 6, 7, 8]
[1, 2, 3, 3, 4, 5, 6, 7, 8]
[1, 2, 3, 3, 4, 5, 6, 7, 8]

4.OOP:面向对象编程。是一种计算机编程架构。

四大特征：抽象，封装，继承，多态

5.Object类的一些常用方法：

.toString():返回代表该对象的字符串形式；格式为类名@内存地址十六进制；

.equals()：判断两个对象是否指向同一内存区域；

.getClass()：得到对象对应的class对象类名；

.hashCode()：得到对象的hash码。

5.static修饰符：可以修饰变量，方法或代码块。

（1:类中的静态变量属于类，而不属于某个特定的对象；

（2:静态成员可以于类名一起使用，而无需实例一个对象；

（3:静态变量或方法页称为类的变量或方法；

（4:静态代表着共享，且唯一；

（5:引用静态变量时建议用类的名字来调用。

静态方法：

（1:类的静态方法只能访问其他的静态成员，不能访问非静态成员；

（2:静态方法中没有this关键字；

（3：静态方法不能被重写为非静态方法。

静态代码块：

static {
		//静态代码块中的code
		System.out.println("静态代码块");
	}

（1:如果需要通过计算来初始化静态变量，可以声明一个静态块；

（2:静态块仅在该类被加载时执行一次；

（3:只能初始化类的静态数据成员；

6.单态模式：采取一定的方法保证在整个软件系统中，某个类只能存在一个对象实例，并且该类只提供一个取得其对象实例的方法。

安全模式：

public class Singleton {
	private static final Singleton SINGLETON=new Singleton();
	//构造函数私有化
	private Singleton() {}
	//提供外部的只有一个获得唯一实例的方法
	public static Singleton getInstance() {
		return SINGLETON;//返回这个唯一实例
	}
}

public class test {
	public static void main(String[] args) {
		Singleton singleton=Singleton.getInstance();
	}

}

效率模式：（只有调用的时候才new）

public class Singleton {
	//只声明
	private static  Singleton singleton=null;
	//提供外部的只有一个获得唯一实例的方法
	public static Singleton getInstance() {
		if(singleton==null) {
			//如果为空就new一个
			singleton=new Singleton();
		}
		return singleton;//不为空返回实例
	}
}

public class test {
	public static void main(String[] args) {
		Singleton singleton=Singleton.getInstance();
	}

}