一、选择排序和快速排序
1、选择排序
原理：给定一个数组，第一个值与后面的每个值比较，要是比它小就调换位置，
然后第二个值与后面的值比较，比它小就调换位置，依次类推
代码实现：
public static void main(String[] args) {
int[] arr = new int[]{12, 5, 8, 9, 3, 7, 45, 12, 32, 14};
System.out.println("原始数组为：");
for (int i = 0; i < arr.length; i++) {
System.out.print(arr[i] + "\t");
}
for (int i = 0; i < arr.length; i++) {
for (int j = i + 1; j < arr.length; j++) {
if (arr[i] >= arr[j]) {
int temp = arr[i];
arr[i] = arr[j];
arr[j] = temp;
}
}
}
System.out.println();
System.out.println("冒泡排序之后的数组为：");
for (int i = 0; i < arr.length; i++) {
System.out.print(arr[i] + "\t");
}
}
2、冒泡排序
原理：
1)比较相邻的元素。如果第一个比第二个大，就交换它们两个
2）对每一对相邻的元素都进行比较，等所有的比较完后最后一个数字是这堆数据里的最大数字
3）重复步骤一，直到排序完成
代码：
public static void main(String[] args) {
int[] arr = new int[]{12, 5, 8, 9, 3, 7, 45, 12, 32, 14};
System.out.println("原始数组为：");
for (int i = 0; i < arr.length; i++) {
System.out.print(arr[i] + "\t");
}
for (int i=0;i<arr.length-1;i++){
for (int j=0;j<arr.length-1-i;j++){
int temp = 0;
if (arr[j]>arr[j+1]) {
temp = arr[j];
arr[j] = arr[j+1];
arr[j+1] = temp;
}
}
}
System.out.println();
System.out.println("冒泡排序之后的数组为：");
for (int i = 0; i < arr.length; i++) {
System.out.print(arr[i] + "\t");
}
}
3、二分查找
作用对象
已经排好序的数组（正序逆序都可以）
原理
每次取中间位置的值与待查关键字比较，如果中间位置的值比待查关键字大，则在前半部分循环这个查找的过程，
如果中间位置的值比待查关键字小，则在后半部分循环这个查找的过程。直到查找到了为止，否则序列中没有待查的关键字
查找的部分代码
public static int biSearch(int []array,int a){
int lo=0;
int hi=array.length-1;
int mid;
while(lo<=hi){
mid=(lo+hi)/2;
if(array[mid]==a){
return mid+1;
}else if(array[mid]<a){
lo=mid+1;
}else{
hi=mid-1;
}
}
return -1;
}
二、方法传递参数时需要注意的点
1、基本数据类型传递参数
public class Demo1{
public static void main(String[] args){
a = 10;
b = 20;
int c = sum(a,b);
System.out.println(a);
System.out.println(b);
System.out.println(c);
}
public static int sum(int a,int b){
a = b;
b = a +b;
return a + b;
}
}
****输出时a=10,b=20,c=60****
总结：
基本数据类型传递的是实际变量的数值，对方法外部变量本身没有任何影响
2、引用数据类型
public class Demo2{
public static void main(String[] args){
int[] arr = new int[]{1,2,3,4,5};
change(arr);
System.out.println(arr[1]);
}
public static void change(int[] array){
for(int i=0;i<=array.length;i++){
if(array[i]%2==0){
array[i] *= 2
}
}
}
}
****输出为4****
总结：
引用数据类型当作实际参数传递的时候，传递的是该引用数据类型的地址值，方法中的操作会影响到其他内存中的数据
三、面向对象编程
1、什么是面向对象的思想
面向对象的思想是基于面向过程思想发展而来的
面向过程：强调的是实现功能每一个步骤，前面的学习也属于面向过程的编程范围
面向对象：强调的是对象，然后由这个对象去调用功能
2、面向对象的特点：
1) 是一种更符合我们思想习惯的思想
2) 可以将复杂的事情简单化
3) 将我们从执行者变成了指挥者
举例：
吃饭：
面向过程的思想：先去菜市场买菜--洗菜--切菜--做菜--装盘--吃
面向对象的思想：你（点菜）--厨师（做菜）--等外卖小哥（送餐）--吃（以点外卖为例）
需求：将大象装进冰箱里
面向过程的思想：
分析过程：
1、打开冰箱门
2、把大象装进冰箱
3、关闭冰箱门
伪代码实现：
class Demo{
public static void main(String[] args){
System.out.println("打开冰箱门");
//为了完成这个过程简单使用三个方法执行他们，只代表面向过程编程的意思
//把打开冰箱门、把大象装进冰箱、关闭冰箱门封装成三个方法，然后调用
open();
put();
close();
}
public static void open(){
//写打开冰箱门的功能实现代码
}
public static void put(){
//写把大象装进冰箱的功能实现代码
}
public static void close(){
//写关闭冰箱门的功能实现代码
}
}
面向对象的思想：
使用面向对象的思想去实现该需求：
1、我们需要考虑该需求中有哪些类？
2、每一个类中都有些什么呢？
3、类与类之间的关系又是什么呢？
1、我们需要考虑该需求中有哪些类？
如何分析有哪些类，
方式1：需要用到UML这门课的知识
方式2：名词提取法
有哪些类呢？
通过名词提取法，我们知道有大象类，冰箱类外加一个测试类
2、每一个类中都有些什么呢？
大象类：
属性：体积，鼻子，脚掌，耳朵...
功能：被装进冰箱，喝水，叫....
冰箱类：
属性：立方体，材质，功率...
功能：打开冰箱门，关闭冰箱门，冷藏，保鲜....
测试类：
main方法，实现需求
3、类与类之间的关系又是什么呢？
测试类中使用大象类和冰箱类的功能
伪代码实现：
//大象类
class Elephant{
体积；
鼻子；
脚掌；
耳朵；
被装进冰箱();
喝水();
叫();
}
//冰箱类
class IceBox{
立方体;
材质;
功率;
打开冰箱门()
关闭冰箱门()
冷藏()
保鲜()
}
//测试类
class Demo2{
public static void main(String[] args){
调用冰箱类中的打开冰箱门的方法;
调用大象类中的被装进冰箱的方法;
调用冰箱类中的关闭冰箱门的方法;
}
}
3、面向对象开发,设计,特征
1）、面向对象的开发：
实际上就是不断创建对象，使用对象，指挥对象做事情的过程
2）、面向对象的设计：
其实就是管理和维护类与类之间的关系的过程
3）、面向对象的特征：
1、封装
2、继承
3、多态
4、使用java语言描述现实生活中的事物
举例：
人
五官，姓名，性别，年龄...
吃饭，学习，说话，敲代码...
水杯
颜色，形状，材质，容积...
装水，泡茶...
属性：用来描述事物的信息
行为：用来描述事物能够做什么
学习编程目的：
我们学习编程语言的目的，其实就是用来模拟现实世界的事物的
而我们现在所学习的语言叫做: java
java中最基本的单位：类
所以，我们通过java把现实世界的事物给描述出来，因此我们要学习如何用java去描述一个现实世界的事物
由此得出一个对应关系：
事物： 类：
属性：用来描述事物的信息 成员变量：用来描述事物的信息
行为：用来描述事物能够做什么 成员方法：用来描述事物能够做什么
类：是一组成员变量和成员方法的集合，其实是一个抽线的概念
对象：是该类事物的具体表现，具体到某一个个体
在Java中表现为
事物：人 类：Person
属性：五官，姓名，性别，年龄... 成员变量：facialFeatures,name,gender,age
行为：吃饭，学习，说话，敲代码... 成员方法：eat(),study(),talk(),coding()
对象：是该类事物的具体表现，具体到某一个个体
学生，老师，医生，程序员...
5、具体实现过程举例（以学生基本信息举例）
/*
类是用来描述现实世界中的事物
学生：
属性：学号，姓名，年龄
行为：吃饭，学习，睡觉
类：
Student:
成员变量：id,name,age
成员方法：eat(),study(),sleep()
*/
package com.day09;
public class Student {
/*定义该类中的成员变量
格式：
修饰符 数据类型 变量名;
目前还没有系统地学习过修饰符，目前不加修饰符
*/
int id; //学号
String name; //姓名
int age; //年龄
/*定义成员方法
目前定义的格式：
修饰符 返回值类型 方法名(参数列表){..}
目前修饰符使用 public static
*/
public static void eat(){
System.out.println("吃饭"); //吃饭
}
public static void study(){ //学习
System.out.println("学习");
}
public static void sleep(){
System.out.println("睡觉"); //睡觉
}
}
********************测试********************
/*
测试学生类
创建对象，调用成员变量和方法
*/
package com.day09;
public class StudentDemo {
public static void main(String[] args) {
/*如何创建对象呢？
格式： 类 对象名(自定义) = new 类名(...);
创建一个学生对象
*/
Student xiaoyang = new Student();
/*如何获取成员变量呢？
格式：
对象名.成员变量名
*/
System.out.println(xiaoyang.id); //获取xiaoyang的学号
System.out.println(xiaoyang.name); //获取xiaoyang的姓名
System.out.println(xiaoyang.age); //获取xiaoyang的年龄
//**********此时因为还没有赋值，所以输出是0**********//
System.out.println("=================赋值后：=================");
/*给成员变量赋值的格式：
对象名.成员变量名 = 成员变量对应的数据类型的值;
*/
xiaoyang.id = 10001; //给xiaoyang这个对象的学号进行赋值
xiaoyang.name = "杨万里"; //给xiaoyang这个对象的姓名进行赋值
xiaoyang.age = 18; //给xiaoyang这个对象的年龄进行赋值
System.out.println(xiaoyang.id); //获取xiaoyang的学号
System.out.println(xiaoyang.name); //获取xiaoyang的姓名
System.out.println(xiaoyang.age); //获取xiaoyang的年龄
/*如何调用该对象中的方法
格式：
对象名.成员方法
调用xiaozhu中的吃饭方法
*/
xiaoyang.eat();
xiaoyang.study();
xiaoyang.sleep();
}
}