排序和面向对象

1. 冒泡

两两相邻比较 遇到条件成立(大于或者小于)就交换位置 经过作图分析： 比较的轮数是长度-1 外层循环控制比较的轮数 每一轮比较的次数 最多的一次是长度-1 依次递减 内层循环控制比较的次数 外层循环 N - 1 内层循环 N - 1 - i

  1. package com.qfedu.test2;
  3. import java.util.Arrays;
  5. /**
  6.  *     冒泡排序
  7.  *     希尔排序 快速排序 堆排序 桶排序 选择排序 猴子排序
  8.  * 
  9.  *     排序：将乱序的一组数列经过算法 排列为升序或者降序
  10.  *     冒泡排序：两两相邻比较 遇到条件成立(大于或者小于)就交换位置
  11.  * 
  12.  *     经过作图分析：
  13.  *     比较的轮数是长度-1  外层循环控制比较的轮数
  14.  *     每一轮比较的次数 最多的一次是长度-1 依次递减 内层循环控制比较的次数 
  15.  * 
  16.  *     外层循环 N - 1 
  17.  *     内层循环 N - 1 - i 
  18.  * @author WHD
  19.  *
  20.  */
  21. public class Test1 {
  22.     public static void main(String[] args) {
  23.         int a  = 10;
  24.         int b = 20;
  25.         int c = a;
  26.         a = b;
  27.         b = c;
  28.         int [] nums = {20,1,55,784,10,233,65};
  29.         for(int i = 0;i < nums.length - 1;i++) {
  30.             for(int j = 0;j < nums.length - 1 - i;j++) {
  31.                 if(nums[j] < nums[j + 1]) {
  32.                     int temp = nums[j];
  33.                     nums[j] = nums[j + 1];
  34.                     nums[j + 1] = temp;
  35.                 }
  36.             }
  37.         }
  38.         System.out.println(Arrays.toString(nums));
  39.     }
  40. }

2. 选择

比较方式：使用一个元素去其他的元素进行比较 遇到需要交换位置的元素 先不交换 等到一轮比较完以后 交换一次位置 比较的次数与冒泡是一样的 但是 交换位置的次数 大大减少了 长度-1 的元素都将充当一遍比较的数A 从第二个元素开始 都将充当一遍比较的数B 外层循环 是比较的数A 内层循环 是比较的数B

  1. package com.qfedu.test3;
  3. import java.util.Arrays;
  5. /**
  6.  *     选择排序
  7.  *     冒泡的方式三个人比高低个：广坤 180 赵四 188    刘能 155
  8.  * 
  9.  *     比较方式：使用一个元素去其他的元素进行比较 遇到需要交换位置的元素 
  10.  *     先不交换 等到一轮比较完以后 交换一次位置
  11.  *     比较的次数与冒泡是一样的 但是 交换位置的次数 大大减少了
  12.  * 
  13.  *     长度-1 的元素都将充当一遍比较的数A
  14.  *     从第二个元素开始 都将充当一遍比较的数B
  15.  *     外层循环 是比较的数A
  16.  *     内层循环 是比较的数B
  17.  * @author WHD
  18.  *
  19.  */
  20. public class Test1 {
  21.     public static void main(String[] args) {
  22.         int [] nums = {20,1,55,784,10,233,65};
  23.         for(int i = 0;i < nums.length - 1;i++) {
  24.             int minIndex = i;
  25.             for(int j = i + 1;j < nums.length;j++) {
  26.                 if(nums[minIndex] > nums[j]) {
  27.                     minIndex = j;
  28.                 }
  29.             }
  31.             if(minIndex != i) {
  32.                 int temp = nums[minIndex];
  33.                 nums[minIndex] = nums[i];
  34.                 nums[i] = temp;
  35.             }
  36.         }
  37.         System.out.println(Arrays.toString(nums));
  39.     }
  40. }

3.JDK自带排序

JDK自带的排序 升序 Arrays.sort(数组名)

  1. package com.qfedu.test4;
  3. import java.util.Arrays;
  5. /**
  6.  *     JDK自带的排序
  7.  *     Arrays.sort(数组名)
  8.  * @author WHD
  9.  *
  10.  */
  11. public class Test1 {
  12.     public static void main(String[] args) {
  13.         int [] nums = {20,1,55,784,10,233,65};
  14.         Arrays.sort(nums); // 升序
  16.         //降序
  17.         int [] newNums = new int[nums.length];
  18.         for(int i = 0,j = nums.length - 1;i < nums.length;i++,j--) {
  19.             newNums[i] = nums[j];
  20.         }
  21.         System.out.println(Arrays.toString(newNums));
  22.         System.out.println(Arrays.toString(nums));
  23.     }
  24. }

4. 二维数组

二维数组 数组中的元素还是数组 创建二维数组的方式还跟之前一样 四种

  1. package com.qfedu.test5;
  2. /**
  3.  *     二维数组  数组中的元素还是数组
  4.  *     我们之前用的都是一维数组
  5.  * @author WHD
  6.  *
  7.  */
  8. public class Test1 {
  9.     public static void main(String[] args) {
  10.         int [] nums1 = {1,2,3,4,5};
  11.         // 声明带赋值 简单
  12.         int [][] nums2 = {{1,2,3}, {4,5,6,7,8,9,5,6,8,6,5,20}, {11,22,33,445} , {89,78,45}};
  13.         System.out.println(nums2[0][0]);
  14.         System.out.println(nums2[0][1]);
  15.         System.out.println(nums2[0][2]);
  17.         System.out.println(nums2[1][0]);
  18.         System.out.println(nums2[1][1]);
  19.         System.out.println(nums2[1][2]);
  21.         // 声明带赋值 繁琐
  22.         int [][] nums3 = new int[][] {{1},{2},{3}};
  24.         // 先声明 再开辟空间
  25.         int [][] nums4;
  26.         nums4 = new int[4][];
  28.         nums4[0] = new int[3];
  29.         nums4[0][0] = 20;
  30.         nums4[0][1] = 21;
  31.         nums4[0][2] = 22;
  33.         nums4[1] = new int[4];
  34.         nums4[1][0] = 11;
  35.         nums4[1][1] = 12;
  36.         nums4[1][2] = 13;
  37.         nums4[1][3] = 14;
  39.         nums4[2] = new int[5];
  40.         nums4[2][0] = 1;
  41.         nums4[2][1] = 1;
  42.         nums4[2][2] = 1;
  43.         nums4[2][3] = 1;
  44.         nums4[2][4] = 1;
  47.         nums4[3] = new int[6];
  48.         nums4[3][0] = 2;
  49.         nums4[3][1] = 2;
  50.         nums4[3][2] = 2;
  51.         nums4[3][3] = 2;
  52.         nums4[3][4] = 2;
  53.         nums4[3][5] = 2;
  56.         for(int i = 0;i < nums4.length;i++) {
  57.             // System.out.println(nums4[i]);
  58.             for(int j = 0;j <nums4[i].length;j++) {
  59.                 System.out.print(nums4[i][j] + "\t");
  60.             }
  61.             System.out.println();
  62.         }
  65.         // 连声明带开辟空间
  66.         int [][]nums5 = new int[2][3];
  67.         for(int i = 0;i <nums5.length;i++) {
  68.             for (int j = 0; j < nums5[i].length; j++) {
  69.                 System.out.print("*");
  70.             }
  71.             System.out.println();
  72.         }
  73.     }
  74. }

初识面向对象

1. 万物皆对象

万物皆对象是指我们可以将任何的事物都分析出属性和行为，理解为对象。

2. 类和对象的关系

类是对象的抽象，对象是类的具体。 由类衍生出对象。

3. 属性和方法

属性：一些事物共有的特征，称之为属性 方法：一些事物共有的动作，称之为方法

4.创建类和对象

  1. package com.qfedu.test6;
  2. /**
  3.  *     万物皆对象
  4.  *     类是对象的抽象 对象是类的具体
  5.  *     学生类
  6.  *     类的组成包括特征(属性) 和 行为(方法)
  7.  *     属性：
  8.  *         名字    String
  9.  *         年龄    int
  10.  *         性别    char
  11.  *         身高    double
  12.  *         学号    String
  13.  *         体重    double
  14.  *         爱好    String
  15.  *         地址    String
  16.  *         ……
  17.  *     行为：
  18.  *         学习
  19.  *         谈恋爱
  20.  *         睡觉
  21.  *         吃饭
  22.  *         做运动
  23.  * @author WHD
  24.  *
  25.  */
  26. public class Student {
  27.     // 属性 也叫实例变量 直接书写在类中
  28.     String name;
  29.     int age;
  30.     double height;
  31.     double weight;
  32.     String stuNo;
  33.     String hobby;
  34.     String address;
  35.     char sex;
  37.     // 方法 实例方法 普通方法 没有static关键字
  38.     public void study() {
  39.         System.out.println("学生学习");
  40.     }
  42.     public void love() {
  43.         System.out.println("谈恋爱");
  44.     }
  46.     public void sleep() {
  47.         System.out.println("睡觉");
  48.     }
  50.     public void sport() {
  51.         System.out.println("做运动");
  52.     }
  55.     public static void main(String[] args) {
  56.         // 没有对象怎么办？ new一个
  57.         // 类名 对象名 = new 类名();
  58.         Student stu1 = new Student();
  59.         // 给对象的属性赋值 使用对象名+.+属性名
  60.         // 
  61.         stu1.name = "赵四";
  62.         stu1.age = 20;
  63.         stu1.address = "象牙山";
  64.         stu1.hobby = "尬舞";
  65.         stu1.sex = '男';
  66.         stu1.stuNo = "zz666";
  67.         stu1.height = 180;
  68.         stu1.weight = 70;
  71.         System.out.println("名字为" + stu1.name);
  72.         System.out.println(stu1.age);
  73.         System.out.println(stu1.sex);
  74.         System.out.println(stu1.height);
  75.         System.out.println(stu1.weight);
  76.         System.out.println(stu1.stuNo);
  77.         System.out.println(stu1.address);
  78.         System.out.println(stu1.hobby);
  80.         // 访问行为 方法 直接使用对象名+.+方法名调用
  81.         stu1.study();
  82.         stu1.love();
  83.         stu1.sleep();
  84.         stu1.sport();
  85.         System.out.println("======================================================");
  86.         // 类相当于模板   我们可以通过类创建很多对象 没有上限
  87.         Student stu2 = new Student();
  88.         stu2.name = "广坤";
  89.         stu2.age = 17;
  90.         stu2.hobby = "口技";
  91.         stu2.address = "象牙山";
  92.         stu2.height = 175;
  93.         stu2.weight = 70;
  94.         stu2.sex = '男';
  95.         stu2.stuNo = "zz888";
  97.         System.out.println(stu2.name);
  98.         System.out.println(stu2.age);
  99.         System.out.println(stu2.sex);
  100.         System.out.println(stu2.height);
  101.         System.out.println(stu2.weight);
  102.         System.out.println(stu2.stuNo);
  103.         System.out.println(stu2.address);
  104.         System.out.println(stu2.hobby);
  106.         stu2.study();
  107.         stu2.love();
  108.         stu2.sleep();
  109.         stu2.sport();
  112.     }
  114. }

打印详细的信息，将属性使用到方法中

  1. package com.qfedu.test7;
  2. /**
  3.  *     属性 
  4.  *     方法
  5.  * 
  6.  *     实例变量：
  7.  *     定义位置：在类中
  8.  *     默认值：有默认值，与数组相同
  9.  *     作用范围：当前整个类中
  10.  *     重名：可以与局部变量重名 局部变量优先 就近原则
  11.  *     生命周期：随着对象的的创建而存在  随着对象被垃圾回收而死亡 GC Garbage Collection
  12.  *     存储位置：实例变量存储在堆中
  13.  * @author WHD
  14.  *
  15.  */
  16. public class Student {
  17.     String name;
  18.     int age;
  19.     char sex;
  20.     double height;
  22.     public void study() {
  23. //        String name = "jack";
  24.         System.out.println(name + "在学习");
  25.     }
  27.     public void play() {
  28.         System.out.println(name + "在玩游戏");
  29.     }
  31.     public void printInfo() {
  32.         System.out.println("我的名字是" + name + ",年龄是" + age + ",身高是" + height + ",性别是" + sex);
  33.     }
  35.     public static void main(String[] args) {
  36.         Student stu1 = new Student();
  37.         stu1.name = "赵四";
  38.         stu1.age = 17;
  39.         stu1.height = 175;
  40.         stu1.sex = '男';
  42.         stu1.study();
  43.         stu1.play();
  44.         stu1.printInfo();
  46.         stu1 = null;
  48.         System.out.println("=================================");
  51.         Student stu2 = new Student();
  52.         stu2.name = "广坤";
  54.         stu2.play();
  55.         stu2.study();
  56.         stu2.printInfo();
  57.         System.out.println("=================================");
  58.         Student stu3 = new Student();// int [] a = new int[10];
  59.         stu3.printInfo();
  61.     }    
  63. }

4.实例变量的特点

实例变量 描述
定义位置 类中
作用范围 整个类中
默认值 有默认值，与数组相同
重名 可以与局部变量重名，局部变量优先使用，就近原则
生命周期 随着对象的的创建而存在 随着对象被垃圾回收而死亡 GC Garbage Collection
存储位置 实例变量存储在堆中