实训笔记-6.2

6.2

一、座右铭

我的故事你说，我的文字我落，我值几两你定，我去何方我挑。

二、新学Java知识

1、算法

1.1 常见的排序算法

1.1.1冒泡排序（Bubble Sort）

1.1.1.1 思想

冒泡排序（Bubble Sort）是一种基础的排序算法，它的思想是对待排序序列从前向后，依次比较相邻元素的大小，若前面元素大于后面元素，则交换这两个元素，这样一趟过去后，最大的元素就会被“冒泡”到序列的末尾。然后再对剩下的元素进行相同的操作，直到整个序列有序。

1.1.1.2 代码

package study;
/**
 * int[] array = new int[] {20,12,32,15,18,25}
 * @author lenovo
 * 20,12,32,15,18,25
 * 第一次排序--选出第一个最大值     5次
 * 	1、12 20 32 15 18 25
 * 	2、12 20 32 15 18 25
 * 	3、12 20 15 32 18 25
 * 	4、12 20 15 18 32 25
 * 	5、12 20 15 18 25 32
 * 第二次排序--选出第二个最大值   4次
 * 	1、12 20 15 18 25 32
 * 	2、12 15 20 18 25 32
 * 	3、12 15 18 20 25 32
 * 	4、12 15 18 20 25 32
 *  第三次排序--选出第三个最大值 3次      第四次  2次    第五次   1次
 *  1、12 15 18 20 25 32
 *	 2、12 15 18 20 25 32
 *	 3、12 15 18 20 25 32
 *  
 */
public class Demo01 {
	public static void main(String[] args) {
		int[] array = new int[] {20,12,32,15,18,25};
		for (int i = 0; i < array.length-1; i++) {
			for (int j = 0; j < array.length-1-i; j++) {
				if (array[j] > array[j+1]) {
					int temp  = array[j];
					array[j] = array[j+1];
					array[j+1] = temp;
				}
			}
		}
		for (int i = 0; i < array.length; i++) {
			System.out.print(array[i]+"\t");
		}
	}
}
//排序结果
12	15	18	20	25	32

1.1.1.3 算法空间复杂度和时间复杂度的计算

• 时间复杂度O(n^2)

  冒泡排序算法的时间复杂度主要由内外两层循环的嵌套决定，外层循环执行n-1次，内层循环执行n-i次，因此总共的基本操作次数为 (n-1) * (n-1)，即n^2-2n+1次，所以算法的时间复杂度为O(n²)。

• 空间复杂度O(1)

  在冒泡排序中，只需要使用几个基本变量来辅助排序，空间复杂度为O(1)。

1.1.2线性查找算法

1.1.2.1 思想

线性查找算法，也称为顺序查找算法，是最简单的一种查找算法。它的基本思想是遍历待查找的数据集合，从头至尾依次对每个元素进行比较，直到找到目标元素为止。

1.1.2.2 代码

package study;
/**
 * 直接查找
 * 二分查找    折半查找
 * @author lenovo
 *
 */
public class Demo02 {
	public static void main(String[] args) {
		int[] array = new int[] {1,2,3,4,5,6,7,8,9};
		int num = 5;
		boolean flag = false;
		for (int i = 0; i < array.length; i++) {
			if (num == array[i]) {
				//System.out.println("找到了该元素，索引为"+i);
				flag = true;
				break;
			}
		}
		if (flag) {
			System.out.println("找到了");
		}else {
			System.out.println("没找到");
		}
	}
}

1.1.2.3 算法空间复杂度和时间复杂度的计算

由于该算法需要依次遍历整个数据集合，所以其时间复杂度为O(n)，其中n为数据集合中元素数量。

1.1.3二分查找算法

1.1.3.1 思想

二分查找算法，也称为折半查找算法，是常见的一种查找算法。对于有序数据集合，可以使用二分查找算法以O(logn)的时间复杂度进行查找。

二分查找的基本思路是：将数据集合按照一定的方式进行分割，从而缩小查找的范围。具体的实现方式是：对于有序的数据集合，设定一个目标元素target以及两个指针left和right，其中left指向数据集合的第一个元素，right指向数据集合的最后一个元素。每次将中间位置mid更新为(left+right)/2的值，然后将目标元素和mid位置的元素进行比较。如果目标元素等于mid位置的元素，则返回mid；如果目标元素小于mid位置的元素，则更新right指针为mid-1；如果目标元素大于mid位置的元素，则更新left指针为mid+1。然后再次按照上述方式进行查找，直到找到目标元素或者确定目标元素不存在为止。

1.1.3.2 代码

package study;

import javafx.scene.control.TableRow;

/**
 * 折半查找：必须保证数组有序
 * 折半查找和核心思想就是每一次查找减少一半的元素比较
 * 三个变量：
 * 1、start
 * 2、end
 * 3、middle = (start+end)/2
 * 
 *  循环的终止条件  end < start
 * @author lenovo
 *
 */
public class Demo03 {
	public static void main(String[] args) {
		int[] array = new int[] {1,2,3,4,5,6,7,8,9};
		int num = 95;
		int start = 0;
		int end = array.length-1;
		boolean flag = false; 
		while (end >= start) {
			int middle = (end+start)/2;
			if (num == array [middle]) {
				//System.out.println("找到了");
				flag = true;
				break;
			}else if (num < array[middle]) {
				end = middle -1;
			}else {
				start = middle +1;
			}
		}
		
		if (flag) {
			System.out.println("找到了");
		}else {
			System.out.println("没找到");
		}
	}
}

1.1.3.3 算法空间复杂度和时间复杂度的计算

该算法的时间复杂度为O(logn)，其中n为数据集合中元素数量，空间复杂度为O(1)。其优点是查找效率高。

2、面向对象思想

2.1 概述

Java语言是一种面向对象的程序设计语言，而面向对象思想是一种程序设计思想，我们在面向对象思想的指引下，使用Java语言去设计、开发计算机程序。这里的对象泛指现实中一切事物，每种事物都具备自己的属性和行为。面向对象思想就是在计算机程序设计过程中，参照现实中事物，将事物的属性特征、行为特征抽象出来，描述成计算机事件的设计思想。它区别于面向过程思想，强调的是通过调用对象的行为来实现功能，而不是自己一步一步的去操作实现。

2.2 举例

• **面向过程：**把衣服脱下来–>找一个盆–>放点洗衣粉–>加点水–>浸泡10分钟–>揉一揉–>清洗衣服–>拧干–>晾起来
• **面向对象：**把衣服脱下来–>打开全自动洗衣机–>扔衣服–>按钮–>晾起来

2.3 区别

• **面向过程：**强调步骤
• **面向对象：**强调对象，这里的对象就是洗衣机。

2.4 特点

面向对象思想是一种更符合我们思考习惯的思想，它可以将复杂的事情简单化，并将我们从执行者变成了指挥者。面向对象的语言中，包含了三大基本特征，即封装、继承和多态。

3、面向对象的两大核心概念：类和对象

类是一类事务的模板，是一个抽象的概念；对象是一类事务真实存在的个体实列。

Java程序的核心就是使用类来组织代码，然后通过类的对象来调用类中声明的属性和方法。

3.1 类的声明语法

访问控制修饰符 class 类名（大驼峰命名法）{
					类体-类的组成成分：
                        属性：声明类的特征的
                        方法：声明类的行为动作的
                        构造器：创建这个类的实例对象，只有有了实例对象我们才能去调用属性和方法
                        代码块：一段可以自己执行的代码区域，一般是在构造器之前执行的
                        内部类：类中声明另一个类，主要的目的是为了对当前类的一些内容做拓展的
}

3.2 类中属性的声明和使用

属性又名成员变量，属性就是一个变量，只不过是直接声明在类中的，因此我们叫做成员变量。成员变量一般是在堆区或者元数据区开启内存空间进行保存。

3.2.1 属性的完整声明语法：

访问控制修饰符 [static] [final] 数据类型 属性名 [= 值];

• 【注意】：

1. 被static修饰的属性，都会在类加载的时候在元数据区域声明出来并且赋值

2. 没有被static修饰的属性，只会在构建该类的对象的时候才会在堆区开辟空间声明属性并且赋值

3. 如果一个属性被static和final关键字同时修饰，那么属性名必须全大写并且使用_拼接，否则属性名必须全大写并且使用**“-”**

   拼接，否则属性名满足小驼峰命名法

4. 属性虽然是变量，但是属性无需手动初始化，当我们构建对象时，如果属性没有初始值JVM内存会默认给属性赋予一个默认值，默认值根据数据类型的不同而不同

   类型	默认值
   整型类型	0
   浮点类型	0.0
   boolean	false
   char	’‘
   引用数据类型	null

3.2.2 属性的调用语法：

1. 给属性赋值：对象名.属性名 = 值;
2. 获取属性的值：对象名.属性值

• 【注意点】

1. 如果属性被static修饰了，除了可以使用对象名来调用，也可以直接使用类名来调用。
2. 被static修饰的属性，都会在类加载的时候在元数据区域声明出来并且赋值，而且一个类只会加载一次
3. 没有被static修饰的属性，只会在构建该类的对象的时候才会在堆区开辟空间声明属性并且赋值，一个对象会创建一个新的内容
4. 一个类中的静态内容只会在内存中存在一份，但是非静态内容一个对象存在一份

3.2.3 代码示例

例一

package work1;
/**
 * 属性又名成员变量  本质上就是一个变量
 * 访问控制修饰符  [static]  [final]  数据类型  属性名  [= 值];
 * 
 * static是面向对象中一个比较特殊的关键字，修饰谁，谁就是静态的
 * 静态的内容有个规则，在类加载的时候，必须把每一个类中的静态内容在元数据区定义声明出来
 * 【注意】：
 * 1、被static修饰的属性，都会在类加载的时候在元数据区域声明出来并且赋值
 * 2、没有被static修饰的属性，只会在构建该类的对象的时候才会在堆区开辟空间声明属性并且赋值
 * 3、如果一个属性被static和final关键字同时修饰，那么属性名必须全大写并且使用_拼接，否则属性名必须全大写并且使用_拼接，
 * 否则属性名满足小驼峰命名法
 * 4、属性虽然是变量，但是属性无需手动初始化，当我们构建对象时，如果属性没有初始值
 * JVM内存会默认给属性赋予一个默认值，默认值根据数据类型的不同而不同
 * 	整数类型         0
 * 	浮点类型         0.0
 * 	boolean         false
 * 	char            ''
 * 	引用数据类型      null
 *
 * @author lenovo
 *
 */
public class FieldStudy {
	/*
	 * public static String name = "zs";
	 * public int age;
	 * public final String school = "中北大学";
	 * public static final int a = 1;
	 */
	
	public static String studentName ="zs";
	public int studentAge;
	public final String studentSchool ="中北大学";
	public static final int SCHOOL_NUMBER = 1;
	
	public static void main(String[] args) {
		//1、创建类的实例对象    类在Java中也是一种数据类型
		//实例对象说白了就是创建这个类的一个变量		类名		对象名  =  new  类名();
		FieldStudy fs = new FieldStudy();
		FieldStudy fs1 = new FieldStudy();
		String s = fs.studentName;
		System.out.println(s);
		System.out.println(fs.studentAge);
		System.out.println(FieldStudy.studentName);
		fs.studentName = "ww";
		System.out.println(fs1.studentName);
	}
	
}

例二

package work1;

public class People {
    public String name;
    public int age;
    public String color ="黄色";
    public String sex="男";
    public static String gene ="xx、xy";
    
    public static void main(String[] args) {
        People dnn = new People();
        dnn.sex = "女";
        dnn.age = 500;
        People syp = new People();
        syp.color = "green";
        syp.gene = "xx、xy、xxx、xxy";
        System.out.println(dnn.gene);
    }
}

3.3 类中的方法声明与使用

3.3.1 定义

方法是一类事务的行为和动作

3.3.2 方法的完整的声明语法

访问控制修饰符 [static] [final] 返回值类型 方法名-小驼峰(形参列表) {

​ 方法体;

}

3.3.3 代码

public class Demo01 {
    public String eat(String food) {
        return "";
    }
    public void tiangou(String grilGod) {
        
    }
    public String breath() {
        return "live";
    }
    public void haiwang() {
        
    } 
}

3.3.4 返回值类型

方法执行完毕给调用者返回的结果，返回值类型有三种情况：

• 基本数据类型
• 引用数据类型
• void

如果返回值类型不是void,那么必须在方法的方法体中的逻辑上的最后一行使用return+该类型的值的方式把结果返回了。