第二周第一天 java 学习笔记

知识点
new Car() 创建一个对象，在主栈
Car.hashCode()打印地址
System.out.print(car)//car 是一个实例对象
具体输出：就是调用的toString 方法
不重写，输出的 包名+地址 例如
new 二维数组
java不能多继承，
多态
static
this super
static 与对象的加载顺序
static 函数
this必须放在第一行
图：

多态：方法重写、方法重载
* 构造函数：方法名与类名一致、无返回值、只在创建对象的时候执行一次（创建一个对象执行一次）
* 方法重写：重写父类的方法
* 方法重载：重载方法名相同，参数不同。
1.java System.out.print(对象.hashCode() )输出的是对象的地址
System.out.print(对象) 输出的是 创建项目的地址+对象地址
System.out.print(car)//car 是一个实例对象
具体输出：就是调用的toString 方法
不重写，输出的 包名+地址

package Two1;
class Car{
	
}
public class text {
	
public static void main(String [] args)
{
	Car car =new Car();
	System.out.println(car);
	System.out.println(car.hashCode());
}
}

输出结果

2.数组
2.1 创建数组必须要把行大小确定，其他的可以在创建数组后再加
a.length //行数 a //数组的地址
a[0].length //列数 a[0] //这一列的地址

int[][] a = new int[4][];
		int[][][] b = new int[5][][];
	for(int i = 0 ; i<b.length;i++){
		b[i] = new int[6][];
		for(int j=0;j<b[i].length;j++){
				b[i][j] = new int[7];
			for(int k = 0 ; k<b[i][j].length;k++){
				b[i][j][k] = (int)(Math.random()*10);
				}
			}
		}

    2.2 如果重新再创建，之前的那个就被舍弃了

int[] c = new int[6];
		System.out.println("c的一维数组地址："+c);
		a[0] = c;
	如果重新再创建，之前的那个就被舍弃了
	c = new int[]{1,2,3,4,5,6,7,8};
	System.out.println("c的一维数组地址第二次："+c);

3.this
3.1 this 必须放在第一行，本类在任何一个构造函数内调用其他构造函数。必须将调用的构造函数放在第一位。
3.2 本类当前对象引用。 为什么静态块不让用就是因为静态块初始化已经在类加载的时候就加载到内存中了。而此时this还没有被创建或者说我们在这个时候内存中还没有Car这个对象
* this() 相当于调用本类的无参构造函数，中间也可以加入参数这样就可以调用几个参数的构造函数。
* java给我们提供了一个快速访问本类的关键字。

4.super 本类当前对象的父类对象引用
super 可以调用父类的对象，就是当前类对象的父类对象。通过super来实现调用父类可以继承的。

5.static
在类创建就加载到内存，不以对象创建为基础，以类为基础
* 静态方法可以被非静态方法调用
* 静态方法无法调用非静态方法及参数。
6.super（） 与this （）不允许同时使用
super();//通过super已经构建了内存
this();//在通过this构建内存不允许。
super（）与this（）都是创建内存空间去了，如果用super了，然后其实我们是在其基础上去在创建。
但是如果再super之后再添加this（）,那么对象就会发现我现在已经有空间了，你又给我创建，我指向那里？
如果先调用this()那么在默认的或者自己书写的都会在构造函数的第一行调用一下super然后创建内存空间。
这样才能通过子类的类对象构造器根据父类的继续构造。

	所以super()与this()不允许同时使用。 

7.快速排序（找一个数就是类似于中间数的概念。然后将内部的其他数根据这个中间数进行比较大的放一侧小的方一侧）
站队我跟后边的人交换我会告知后边的人你到前边来，你问问你后边跟我比
* 我跟前面的人交换我会告知前边的人你到后边来 你问问你前边跟我比
递归算法
* 第一遍最长 然后分拆成两端，然后再分拆，知道i=j代表就一个数了不遍历了
*
*
* i j
* 取一个标准数： 92 92和a[j]{52}比 92和52进行地址交换 将
* a{52,63,81,74,65,2,25,36,78,49,92}
* i+1=j
* a1{52,63,81,74,65,2,25,36,78,49} a2{92}
* i j 52与49进行交换
* a1{49,63,82,74,65,2,25,36,78,52}
* i+1 j 63与52进行交换
* a1{49,52,82,74,65,2,25,36,78,63}
* i+1 j-- 52与36进行交换
* a1{49,36,82,74,65,2,25,52,78,63}
* i j 82与52进行交换
* a1{49,36,52,74,65,2,25,82,78,63}
* i j 52与25交换
* a1{49,36,25,74,65,2,52,82,78,63}
* i j 74与52交换
* a1{49,36,25,52,65,2,74,82,78,63}
* i j 52与2进行交换
* a1{49,36,25,2,65,52,74,82,78,63}
* i j 65与52进行交换
* a1{49,36,25,2,52,65,74,82,78,63}
* i j-- i==j–
* a11{49,36,25,2} a12{65,74,82,78,63}
* 52
* 每次找寻到基数应该在整个排序过程中的定位。
* 0~i j~最后
* 取基数 52

public static void main(String[] args) {
		int[] a = {92,63,81,74,65,2,25,36,78,49,52};
		quickSort(a,0,a.length-1);
		for(int i=0;i<a.length;i++){
			System.out.print(a[i]+";");
		}
	}
	
	/**
	 * 排序方法
	 * 递归算法，一遍一遍进入
	 */
	public static void quickSort(int[] a,int low,int high){
		if(low < high){//循环结束条件
			//取到中间的位置
			int m = part(a,low,high);//经过一次交换，可以确定m左边的数一定小于m上的数，右边也是，但不能保证两边有序，所以继续交换两边，直到完成排序
			quickSort(a,low,m-1);
			quickSort(a,m+1,high);
		}
	}
	/**
	 * 交换算法 
	 * 返回告知我定位在哪里
	 */
	public static int part(int []a ,int low,int high) {
		//取出基数
		int x = a[low];
		while(low < high){//low==high结束
			while( low < high && a[high] >= x){
				high --;
			}//找到小于x的下标
		
			a[low] = a[high];	//将后端数据存入前端，放到基数的位置
			
//			a[high] = x;//将中间数存入后端。 因为我要一直变  这行有没有都一样
			while( low < high && a[low] <= x){
				low ++;
			}//找大于等于x的下标
			a[high] = a[low];
			
		}
		a[high] = x;
		return high;//也可以返回high  因为循环终止是low==high
		
	}
	
}

提出一个问题 1.时间复杂度以及如何计算
2.基准x,是第一个是怎么移到中间的
答2.
x循环结束 h==l
要循环结束上一步 l++ 或h–
l++ h 上的数已经放到了上一个上，另一个也是如此
循环结束的时候 我当前的数已经备份，左边的小于，有贬大于。

有的基准在中间，可以把他换到第一个，也可以不管。