第七天笔记

排序和初识面向对象

1.排序

1.1冒泡排序

比较规则：两个相邻的数进行比较，如果符合条件（大于或者小于当前）那么就交换位置；

外层循环：控制比较的轮数 永远是长度 -1 n-1；

内层循环：控制每一轮比较的次数 最多的一次是长度-1 依次递减 n-1-i；

此处有图片

package com.qfedu.test1;

import java.util.Arrays;

/**
 * 	常见的排序：希尔排序，快速排序，猴子排序，桶排序，二叉树排序
 * 	冒泡排序
 * 	将数组中错乱的数据，排序为升序或者降序
 * 	两个相邻的数比较，如果符合条件(大于或者小于当前数)就调换位置
 * 	上学排座位
 * 
 * 	外层循环控制的是比较的轮数 轮数永远是数组的长度 - 1
 * 	内层循环控制的是每一轮比较的次数 最多的一次是长度 - 1  然后依次递减 
 * 	外层循环 n - 1   n是数组的长度 
 * 	内层循环 n - 1 -i 
 * 	内层循环调换位置
 * @author WHD
 *
 */
public class Test1 {
	public static void main(String[] args) {
		int [] nums = {1,56,2,33,120,89};
		int count = 0;
		for(int i = 0;i < nums.length - 1;i++) {
			for(int j = 0;j < nums.length - 1 -i;j++) {
				if(nums[j] < nums[j+1]) {
					int temp = nums[j];
					nums[j] = nums[j+1];
					nums[j+ 1] = temp;
					count ++;
				}
			}
		}
		
		
		System.out.println(Arrays.toString(nums));
		
		System.out.println(count);
		
		int a = 10;
		int b = 20;
		
		
		int temp = a; // 10
		a = b; // 20
		b = temp; // 10
		
	}
}

1.2选择排序

比较规则：使用第一个元素依次与后边的元素进行比较，如果遇到需要交换位置的元素，不立即换位置，先交换下标，在比较下一轮完成以后，统一交换一次位置

与冒泡排序的区别：比较次数是一样的，唯独交换的次数大大减少，提高效率

外层循环：属于比较的数A 判断条件为n - 1；

内层循环：属于比较的数B 起始位置为i + 1 开始

此处有图片

package com.qfedu.test1;

import java.util.Arrays;

/**
 * 	选择排序 
 * 	冒泡排序的缺点：
 * 	比如有三个人按照高低个排座位  赵四185  广坤192 大拿 175    赵四---大拿 -- 广坤 
 * 	选择排序：
 * 	使用第一个元素依次与后边的元素进行比较，如果遇到需要交换位置的元素，不是立即交换位置，而是交换下标
 * 	然后继续拿着交换以后下标的元素继续重复以上动作
 * 	等着一轮比较完了以后 交换一次位置即可
 * 
 * 	经过分析：
 * 	1.选择排序和冒泡排序比较的次数是一样的，但是交换的次数是大大减少的
 * 	2.外层循环属于比较的数A   内层循环属于比较的数B
 * 	
 * @author WHD
 *
 */
public class Test2 {
	public static void main(String[] args) {
		int [] nums = {-2,56,1,33,-1,120,89};
		int count  = 0;
		for(int i = 0;i < nums.length -1;i++) {
			int minIndex = i; // 最小元素的下标 为 i
			for(int j = i + 1;j <nums.length;j++) {
				if(nums[minIndex] > nums[j]) {
					minIndex = j;
				}
			}
			
			if(minIndex != i) {
				count++;
				int temp = nums[i];
				nums[i] = nums[minIndex];
				nums[minIndex] = temp;
			}
		}
		
		System.out.println("一共交换了" + count + "次位置");
		System.out.println(Arrays.toString(nums));

		
	}
}

1.3JDK提供的排序方法

Arrays类中提供的sort()方法用于将数组排序，升序

package com.qfedu.test2;

import java.util.Arrays;
/**
 * 	Arrays提供的常用方法
 * 	toString()将数组内容转换为字符串
 * 	copyOf() 复制数组
 * 	sort()排序 升序
 * @author WHD
 *
 */
public class Test1 {
	public static void main(String[] args) {
		int [] nums = {1,25,66,20,78};
		Arrays.sort(nums);
		System.out.println(Arrays.toString(nums));
		
		int [] nums1 = new int[nums.length];
		// 非常规方式 将数组中的内容反转
		for(int i  = nums.length - 1,j = 0;i >= 0; i --,j++) {
			nums1[j] = nums[i];
		}
		System.out.println(Arrays.toString(nums1));
		
	}
}

2.二维数组

二维数组是指数组中的元素还是数组，定义时有两个[]，声明数组时必须指定高维度的长度，低维度不可写。

package com.qfedu.test2;
/**
 * 	二维数组 数组的维度没有上限 
 * 	二维数组相当于 有行 有列的结构  
 * 	在定义数组的时候，高维度(第一个中括号)的长度必须制定，低维度(第二个中括号)可以不指定
 * @author WHD
 *
 */
public class Test2 {
	public static void main(String[] args) {
		int [] nums1 = new int[3];
        // 方式1 先声明 再分配空间
        int [][] nums5;
        nums5 = new int[3][];
		// 方式2 声明并且分配空间
		int [][] nums2 = new int[3][3];
		nums2[0][0] = 20;
		nums2[0][1] = 22;
		nums2[0][2] = 23;
		
		
		nums2[1][0] = 55;
		nums2[1][1] = 56;
		nums2[1][2] = 57;
		
		
		
		nums2[2][0] = 66;
		nums2[2][1] = 67;
		nums2[2][2] = 68;
		// 遍历二维数组
		for(int i = 0;i < nums2.length;i++) {
//			System.out.println(nums2[i]); 因为数组中的每个元素还是数组 所以不能直接输出
			for(int j = 0;j < nums2[i].length;j++) {
//				System.out.print(nums2[i][j] + "\t");
				System.out.print("*");
			}
			System.out.println();
		}
		
		
		// 方式3 声明数组并且赋值
		int [][] nums3 = {{1,2,3},{2,3,4,5},{5,6,7,8,9,10}};
		
		for (int i = 0; i < nums3.length; i++) {
			for (int j = 0; j < nums3[i].length; j++) {
				System.out.print(nums3[i][j] + "\t");
			}
			System.out.println();
		}
		
		// 声明数组 并且分配高维度的空间
		int [][] nums4 = new int[2][];
		// 单独给每一个数组元素开辟空间 
		nums4[0] = new int[3]; 
		nums4[1] = new int[5];
		
		
		nums4[0][0] = 1;
		nums4[0][1] = 1;
		nums4[0][2] = 1;
		
		nums4[1][0] = 2;
		nums4[1][1] = 2;
		nums4[1][2] = 2;
		nums4[1][3] = 2;
		nums4[1][4] = 2;

	}

3.面向对象

3.1万物皆对象

世界上任何物体，有生命或者没有声明都可以理解为是一个对象，我们通常将这些对象按类划分

类的属性：多个对象共有的特征，我们将其抽取出来，作为类的属性；

类的方法：多个对象共有的行为，我们将其抽取出来，作为类的方法；

类和对象的关系：

类是对象的抽象，对象是类的具体；

类相当于一个模板，规范了对象的属性和行为，一个类可以产生多个对象；

3.2创建类的使用对象

类是程序中的基本组织单元

创建类的步骤：

1.先分析特征（属性）；

2.再分析行为（方法）；

创建对象：

类名 对象名 = new 类名();

使用对象：访问对象的属性和方法

使用对象名+.的方式 来访问属性和方法

package com.qfedu.test3;

import java.util.Scanner;

/**
 * 	学生类
 * 	分析：
 * 	学生有哪些属性？
 * 	属性直接定义在类的内部   实例属性
 * 	姓名
 * 	性别
 * 	年龄
 * 	身高
 * 	学号
 * 	地址
 * 	班级
 * 	体重
 * 	学生有哪些行为？
 * 	学习
 * 	睡觉
 * 	打游戏
 * 	做运动
 * 	类是对象的抽象，对象是类的具体
 * 	类相当于一个模板，规范对象的属性和行为 
 * @author WHD
 *
 */
public class Student {
	String name; // 姓名
	char sex; // 性别
	int age; // 年龄
	double height; // 身高
	String stuNo; // 学号 zz2008001
	String address; // 地址
	String gradeName;
	double weight; // 体重
	String idCard;
	
	// 行为 方法 不要加static
	
	public void study() {
		System.out.println(name + "在认真学习，学到10:30");
	}
	
	public void sleep() {
		System.out.println(name + "在睡觉，睡到6:30");
	}
	
	public void playGame() {
		System.out.println(name + "玩游戏");
	}
	
	public void sport() {
		System.out.println(name + "单人运动");
	}
	
	// 通过类来创建对象  语法： 类名称     对象名  =  new 类名称();
	// 通过对象来访问 类中的属性 和 行为  语法： 对象名.属性名 访问属性  对象名.方法名 访问方法
	public static void main(String[] args) {
		Student stu1 = new Student();
		stu1.name = "赵四";
		stu1.age = 17;
		stu1.stuNo = "zz666";
		stu1.sex = '男';
		stu1.gradeName = "三年二班";
		stu1.height = 178.5;
		stu1.weight = 70;
		stu1.address = "象牙山";
		

		System.out.println("学生的名字是" + stu1.name);
		System.out.println("学生的年龄是" + stu1.age);
		
		
		stu1.study();
		stu1.sleep();
		stu1.playGame();
		stu1.sport();
		
		
		Scanner input1 = new Scanner(System.in);
		Scanner input2 = new Scanner(System.in);

		Student stu2 = new Student();
		stu2.name = "广坤";
		// stu2.idCard = "1026546187612321";
		
		stu2.age = 18;
		stu2.address = "象牙山";
		stu2.gradeName = "三年二班";
		stu2.height = 180;
		stu2.sex = '男';
		stu2.weight = 75;
		stu2.stuNo = "zz888";
		
		stu2.study();
		stu2.sleep();
		stu2.playGame();
		stu2.sport();
		
		
		Student stu3 = new Student();
		stu3.name = "宋小宝";
		stu3.sex = '男';
		
		stu3.study();
		stu3.sleep();
		stu3.playGame();
		stu3.sport();

	}
}

3.3实例变量与局部变量的区别

实例变量直接定义再类的内部，有默认值，与数组相同，当前类中，不管是否赋值都可以直接使用

此处有图片

package com.qfedu.test3;
/**
 * 	人类
 * 	属性：姓名，性别，年龄
 * 	行为：吃饭 学习 自我介绍
 * @author WHD
 *
 */
public class Person {
	String name;
	char sex;
	int age;
	
	public void eat() {
		String name = "abcd";
		System.out.println(name + "在吃饭");
	}
	
	public void study() {
		System.out.println(name + "在学习");
	}
	
	
	public void printInfo() {
		System.out.println("我的名字是" + name + "\t性别是" + sex + "\t年龄是" + age );
	}
		
	public static void main(String[] args) {
		Person p1 = new Person();
		p1.name = "赵四";
		p1.sex = '男';
		p1.age = 17;
		
		p1.eat();
		p1.study();
		p1.printInfo();
		
		Person p2 = new Person();
//		p2.name = "广坤";
//		p2.sex = '男';
//		p2.age = 18;
		
		p2.eat();
		p2.study();
		p2.printInfo();
	}

	
}