首页 > 编程语言 >JAVA知识点总结1

JAVA知识点总结1

时间：2023-05-09 22:00:26浏览次数：48  
标签：总结 知识点 arr JAVA int System println public out

目 录

1. 关键字
2. 数据类型
3. 运算符
4. 流程控制语句

5. 数组

6. 面向对象(Obiect Oriented Programming)

1.关键字

用于定义数据类型的关键字：

class interface enum byte short
int long float double char
boolean void

用于定义流程控制的关键字：

if else switch case default
while do for break continue
return

用于定义访问权限修饰符的关键字：
private protected public

用于定义类，函数，变量修饰符的关键字：
abstract final static synchronized

用于定义类与类之间关系的关键字：
extends implements

用于定义建立实例及引用实例，判断实例的关键字：
new this super instanceof

用于异常处理的关键字：
try catch finally throw throws

用于包的关键字：
package import

其他修饰符关键字：
native strictfp transient volatile assert
const goto

用于定义数据类型值得字面值：
true false null

2.数据类型

2.1基本数据类型

整形数据类型

类型 占用存储空间 范围 注意点
byte 1字节（8bit） -128~127
short 2字节 -215~215-1
int 4字节 -231~231-1(大约21亿)
long 8字节 -263~263-1 赋值时需要以l或L作为后缀

浮点类型

类型 占用存储空间 范围 注意点
单精度float 4字节 -3.403e38~3.403e38 赋值时需要以f或F作为后缀
双精度double 8字节 -1.798e308~1.798308

字符类型

类型 占用存储空间 范围 注意点
char 2字节

布尔类型

类型 占用存储空间 取值 注意点
boolean 1字节 true false

自动类型提升：

byte 、 short 、char ---> int ---> long ---> float ---> double

强制类型转换：

格式：数据类型1 变量名 = （数据类型1）被强制转换的数据

2.2引用数据类型

类(class) 、 数组(array) 、 接口(interface) 、 枚举(enum) 、 注解(annotation) 、 记录(record)

3.运算符

按照功能分类

算术运算符(7个)

运算符 运算 范例 结果
+ 加（正号） 5+5 ; +5 10 ; 5
- 减（负号） 6-4 ; -5 2 ; -5
* 乘 3*4 12
/ 除 5/5 1
% 取余（取模） 7%5 2
++ 自增 a=1; b=1; a++ ； ++b; a=1 ; b=2
-- 自减 a=1; b=1; a-- ; --a; a=1 ; b=0
+ 字符串连接符 "Hell"+"o" "Hello"

赋值运算符(12个)

赋值运算符 符号解释
+= 将符号左边的值和右边的值做相加操作，最后将结果赋值给左边的变量
-= 将符号左边的值和右边的值做相减操作，最后将结果赋值给左边的变量
*= 将符号左边的值和右边的值做相乘操作，最后将结果赋值给左边的变量
/= 将符号左边的值和右边的值做相除操作，最后将结果赋值给左边的变量
%= 将符号左边的值和右边的值做取余操作，最后将结果赋值给左边的变量

比较运算符(6个)

运算符 运算 范例 结果
== 相等于 4==3 false
!= 不等于 4!=3 true
< 小于 4<3 false
> 大于 4>3 true
<= 小于等于 4<=3 false
>= 大于等于 4>=3 true
instanceof 检查是否是类的对象 "Hello" instanceof String true

逻辑运算符(6个)

image

位运算符(7个)

image

条件运算符(1个)

三元运算符：格式：(条件表达式) ? true 表达式1 : false 表达式2

Lambda运算符(1个)

->

4.流程控制语句

程序设计中规定三种流程结构

顺序结构
程序从上到下逐行地执行，中间没有任何判断和跳转
分支结构
根据条件，选择性地执行某行代码。
if-ellse 和 switch-case两种分支语句
循环结构
根据循环条件，重复性的执行某段代码
有for 、 while 、do-while三种循环语句
补充：JDK1.5提供了foreach循环，方便的变量集合、数组元素

4.1 if else

1. 格式1
if(条件表达式){
	语句块1;
}

2. 格式2
if(条件表达式){
	语句块1;
}else{
	语句块2;
}
3. 格式3
if(条件表达式){
	语句块1;
}else if(条件表达式2){
	语句块2;
}
. . .
}else if(条件表达式n){
	语句块n;
}else{
	语句块n+1;
}

image
案例：

public class IfElseTest {
    public static void main(String[] args){
        //案例1：判断心跳是否正常
        int heart = 89;
        if ((heart >= 60) & (heart<= 100) ){
            System.out.println("心跳属于正常!");
        }else{
            System.out.println("心跳不正常!");
        }

        //案例2：判断一个数是奇数还是偶数
        int num = 10;
        if (num % 2 == 0){
            System.out.println(num+"是偶数！");
        }else{
            System.out.println(num+"奇数");
        }

        //案例3：考试成绩打分
        int grade = 60;
        if (grade ==100 ){
            System.out.println("奖励一辆跑车");
        }else if (grade > 80 && grade <= 99){
            System.out.println("奖励一辆山地自行车");
        }else if (grade > 60){
            System.out.println("奖励环球影城一日游");
        }else{
            System.out.println("胖揍一顿");
        }


        //案例4：三个数排序
        int num1 = 123;
        int num2 = 234;
        int num3 = 235;
        if (num1>num2){
            if (num3 > num1) {
                System.out.println(+num2+num1+num3);
            }else if (num3 < num2){
                System.out.println(num1+","+num2+","+num3);
            }else{
                System.out.println(num2+","+num3+","+num1);
            }
        }else{
            if (num3 >num2 ){
                System.out.println(num1+","+num2+","+num3);
            }else if (num3 <= num1){
                System.out.println(num3+","+num1+","+num2);
            }else{
                System.out.println(num1+","+num3+","+num2);
            }


            //案例5：交换大小
            int small = 10;
            int big = 9;
            if (small > big){
                int temp = small;
                small = big;
                big = temp;
            }
            System.out.println(big+","+small);


            //案例6：判断两数之和
            int num4 = 22,num5 = 32;
            if ((num4+num5)>50){
                System.out.println("hello world");
            }
        }
    }
}

4.2 Scanner类从键盘获取数据

使用Scanner从键盘上获取不同类型的变量步骤：
  1. 导包 import java.util.Scanner
  1. 提供(或创建)一个Scanner类的实例
  1. 调用Scanner类中的方法，获取指定类型的变量
  1. 关闭资源，调用Scanner类的close()
//导包
import java.util.Scanner;

public class ScannerTest {
    public static void main(String[] args){
        System.out.println("hello！欢迎来到交友网站!");
        //提供一个Scanner类的实例
        Scanner scanner = new Scanner(System.in);
        System.out.print("请输入你的网名：");
        //调用Scanner类中的方法，获取指定的类型的变量
        String name = scanner.next();
        System.out.print("请输入你的年龄:");
        int age = scanner.nextInt();
        System.out.print("请输入你的体重:");
        double weight = scanner.nextDouble();
        System.out.print("请输入你的是否单身？true:单身 false：不单身:");
        boolean single = scanner.nextBoolean();
        System.out.print("请输入你的性别:(男\\女)");
        char gender = scanner.next().charAt(0);
        System.out.println("网名:"+name+"年龄:"+age+"体重:"+"是否单身:"+single+"性别:"+gender);
        System.out.println("注册完成欢迎！来到交友网站.");

        scanner.close(); //关闭资源
    }
}

4.3 获取一个随机数

random()调用后会返回一个[0.0,1.0)范围的double型的随机数
公式：(int)(Math.random() * (b - a -1)) + a

//获取一个[a,b]范围的随机整数
//    (int)(Math.random() * (b - a -1)) + a
public class RandomTest {
    public static void main(String[] args){
        double d1 = Math.random();  //0.0到1.0
        System.out.println("d1 ="+d1);
        int b1 = (int) (Math.random()*101); //0到100
        System.out.println("b1:"+b1);
        int b2 =(int) (Math.random()*100)+1; //1到100
        System.out.println("b2:"+b2);
        int b3 = (int)(Math.random()*(70+1))+10;     //10到80
        System.out.print("b3:"+b3);
    }
}

4.4 switch-case

语法格式

/*
语法格式：
switch(表达式){
    case 常量1:
        执行语句1;
        break;
    case 常量2:
        执行语句3;
        break;
    . . .
    default:
        执行语句2;
        break;
}
 */

import java.util.Scanner;

public class SwitchCaseExpr {
    public static void main(String[] args){
        int score1 = (int)(Math.random()*6)+1;
        int score2 = (int)(Math.random()*6)+1;
        int score3 = (int)(Math.random()*6)+1;
        Scanner scan = new Scanner(System.in);
        System.out.println("请输入你的选择：豹子，大，小:");
        String a = scan.next();
        boolean result = false;
        switch (a){
            case "豹子" -> result = (score1==score2) && (score2==score3);
            case "大"  -> result = (score1 + score2 + score3 > 9);
            case "小"  -> result = (score1+score2+score3 <=9);
            default -> System.out.println("输入有误请重新输入！");
        }
        System.out.printf("%d,%d,%d" ,score1,score2,score3);
        System.out.println("结果:"+(result?"猜对了！":"猜错了！"));
    }
}

说明:switch中的表达式只能是特定类型的数据类型。如下：byte 、 short 、 char 、 int 、 枚举 (JDK5.0新增)、String(JDK7.0)

public class SwitchCaseTest {
    public static void main(String[] args){
        int num = 4;
        switch(num){
            case 0:
                System.out.println("zero");
                break;
            case 1:
                System.out.println("one");
                break;
            case 2:
                System.out.println("two");
                break;
            case 3:
                System.out.println("three");
                break;
            default:
                System.out.println("other");
        }
        String season = "summer";
        switch (season){
            case "spring":
                System.out.println("春暖花开");
                break;
            case  "summer":
                System.out.println("夏日炎炎");
                break;
            case "winter":
                System.out.println("冬雪皑皑");
                break;
            case "autumn":
                System.out.println("秋高气爽");
                break;
            default:
                System.out.println("季节输入有误");
                break;
        }
    }
}

4.5 for循环

/*
格式:
for(初始化条件;循环条件;迭代部分){
    循环体
}
 */
public class ForTest1_shuixianhua {
    public static void main(String[] args){
        for(int i = 100;i<=999;i++){
            int m = i %10;
            int n = (i % 100) / 10;
            int a = i / 100;
            if (m*m*m+n*n*n+a*a*a==i){
                System.out.print(i+" ");
            }

        }
    }

}

4.6 while循环

//计算一张纸折多少次可以超过珠峰的高度
/*
格式:

初始化条件
while(循环条件){
    循环体
    迭代部分
}
 */
public class WhileTest2 {
    public static void main(String[] args){
        double paper = 0.1;
        double zf = 8848860;
        int count = 0;

        while (paper<=zf){
            paper *=2;
            count++;
        }
        System.out.println("折纸的厚度为"+paper/1000+"米");
        System.out.println("一共折纸"+count+"次");
    }
}

//猜数字
import java.util.Scanner;

public class WhileTest1 {
    public static void main(String[] args){
        //1. 生成一个[1,100]的随机整数
        int random = (int)(Math.random()*100)+1;
        Scanner scan = new Scanner(System.in);
        System.out.print("请输入一个100以内的数:");
        //2. 使用Scanner，从键盘获取数据
        int guess = scan.nextInt();
        int count= 1;
        //3.使用循环结构，进行多次循环的对比和获取数据
        while (guess != random ){
            if (guess>random){
                System.out.println("你输入的数偏大！");
            }else{
                System.out.println("你输入的数偏小！");
            }
            count++;
            System.out.print("请输入一个100以内的数:");
            guess = scan.nextInt();
        }
        System.out.println("猜的数为："+random);
        System.out.println("一共猜了"+count+"次");
    }
}

4.7 do-while循环

说明：do-while循环至少执行一次循环体

/*
格式:
初始化部分;
do{
    循环体部分
    迭代部分
}while(循环条件部分)
 */
//模拟ATM取款
import java.util.Scanner;

public class DoWhileTest1 {
    public static void main(String[] args){
        int balance = 0;  //用户余额,显示用户余额
        boolean flag= true;  //用于判断是否结束
        Scanner scan = new Scanner(System.in);
        do{
            System.out.println("========ATM=======");
            System.out.println("1.存款");
            System.out.println("2.取款");
            System.out.println("3.显示余额");
            System.out.println("4.退出");
            System.out.print("请选择（1-4）:");
            int choice = scan.nextInt();
            switch(choice) {
                case 1:
                    System.out.println("请输入存款金额:");
                    int put = scan.nextInt();  //从键盘获取存储的金额
                    if (put>0){
                        balance += put;
                    }
                    break;
                case 2:
                    System.out.println("请输入取款金额:");
                    int get = scan.nextInt(); //从键盘获取取款金额
                    if (get>0 && balance>get){
                        balance -= get;
                    }else{
                        System.out.println("您输入的信息有误或余额不足！");
                    }
                    break;
                case 3:
                    System.out.println("您当前的余额为:"+balance);
                    break;
                case 4:
                    flag = false;
                    break;
                default:
                    System.out.println("输入有误请重新输入！");
            }
        }while(flag);
    }
}

5. 数组

数组的特点：

  • 数组本身是引用数据类型，但是数组中的元素可以是任何数据类型。
  • 创建数组对象会在内存中开辟一整块连续的空间。占据的空间的大小取决于数组的长度和数组中的元素的类型。
  • 数组中的元素在内存中是依次紧密排列的，有序的。
  • 数组，一旦初始化完成，其长度就是确定的。数组的长度一旦确定就不能修改。
  • 可以通过数组的下标（或索引）的方式调用指定位置的元素，速度很快。
  • 数组名中引用的是这块连续空间的首地址。

案例：杨辉三角形的构造

public class YangHui {
    public static void main(String[] args) {
        //创建二维数组
        int[][] yanghui= new int[10][];
        //使用循环结构初始化
        for (int i = 0; i < yanghui.length; i++) {
            yanghui[i] = new int[i+1];
            //给数组的元素赋值
            //给每行首末元素为1
            yanghui[i][0]=1;
            yanghui[i][i] = 1;
            //给非首行末赋值
            for (int j = 1; j < yanghui[i].length-1; j++) {
                yanghui[i][j] = yanghui[i-1][j] +yanghui[i-1][j-1];
            }
        }

        //遍历二维数组
        for (int i = 0; i < yanghui.length; i++) {
            for (int j = 0; j < yanghui[i].length; j++) {
                System.out.print(yanghui[i][j]+"\t");
            }
            System.out.println();
        }
    }
}

5.1 一维数组的基本使用

public class Basic_use {
    public static void main(String[] args) {
        //1. 数组的声明与初始化
        //1.1 声明数组
        double[] prices;

        //1.2 初始化数组
        //静态初始化:数组变量与数组元素赋值同时进行
        prices = new double[]{20,23,24,25,26};

        String[] foods;
        //动态初始化:分开进行
        foods = new String[5];

        //其他正确的写法
        int arr[] = new int[4];
        int[] arr1 = {1,2,3,4}; //类型推断

        //2. 数组元素的调用
        //通过角标的方式来获取
        System.out.println(prices[0]);
        System.out.println(prices[1]);
        System.out.println(prices[2]);
        System.out.println(prices[3]);
        System.out.println(prices[4]);
//        System.out.println(prices[5]); 报异常: ArrayIndexOutOfBoundsException
        foods[0] = "拌海蜇";
        foods[1] = "龙须菜";
        foods[2] = "炝冬笋";
        foods[3] = "玉米片";
        foods[4] = "酱茄子";
//        foods[5] = "酱茄子"; 报异常: ArrayIndexOutOfBoundsException

        //3. 数组的长度:用来描述数组中容量的大小
        System.out.println(foods.length);

        //4. 遍历数组
        for(int i =0;i<foods.length;i++)
                System.out.println(foods[i]);

        for (int i = 0; i < prices.length; i++) {
            System.out.println(prices[i]);

        }
    }
}

案例：

import java.util.Scanner;

public class ArrayTest {
    public static void main(String[] args) {
        String arr1[] = {"Monday","Tuesday","Wednesday", "Thursday","Friday","Saturday","Sunday"};
        Scanner scan= new Scanner(System.in);
        boolean isOut = true;
        do{
            System.out.print("请输入1-7（代表星期数）0代表退出:");
            int choice = scan.nextInt();
            switch(choice){
                case 0:
                    System.out.println("退出！");
                    isOut = false;
                    break;
                case 1:
                    System.out.println(arr1[0]);
                    break;
                case 2:
                    System.out.println(arr1[1]);
                    break;
                case 3:
                    System.out.println(arr1[2]);
                    break;
                case 4:
                    System.out.println(arr1[3]);
                    break;
                case 5:
                    System.out.println(arr1[4]);
                    break;
                case 6:
                    System.out.println(arr1[5]);
                    break;
                case 7:
                    System.out.println(arr1[6]);
                    break;
            }
        }
        while(isOut);
        System.out.print("请输入1-7的数值:");
        int choice = scan.nextInt();
        if (choice >7 ||choice<1){
            System.out.println("输入有误！");
        }else{
            System.out.println(arr1[choice-1]);
        }
        scan.close();
    }
}

//随机赋值，要求数各不相同
public class ArrayTest4 {
    public static void main(String[] args) {
        int[] arr = new int[6];
        for (int i = 0; i < arr.length; i++) {
            arr[i] = (int) (Math.random()*30)+1;
            boolean flag = false;
            while(true){
                for (int j = 0; j < i; j++) {
                    if(arr[j]==arr[i]){
                    flag = true;
                    break;
                    }
                }
                if (flag){
                    arr[i] =(int) (Math.random()*30)+1;
                    flag= false;
//                    continue;
                }
                break;
            }
        }
        for (int i = 0; i < arr.length; i++) {
            System.out.print(arr[i] + "\t");
        }
    }
}

5.2 二维数组的基本使用

public class TwoArrayBasic {
    public static void main(String[] args) {
        //1. 数组的声明与初始化
        //静态初始化
        int[][] arr1 = new int[][]{{1, 2, 3}, {4, 5}, {6, 7, 8, 9}};
        //动态初始化
        String[][] arr3 = new String[3][4];

        double[][] arr4 = new double[3][];
        //其他正确写法
        int arr5[][] = new int[][]{{1,2,3},{3,4},{5,6,7}};
        int[] arr6[] = new int[][]{{1,2,3},{3,4},{5,6,7}};
        int arr7[][] = {{1,2,3},{3,4},{5,6,7}}; //类型推断

        //2. 数组元素调用
        //调用内层元素
        System.out.println(arr1[1][1]);
        System.out.println(arr1[0][0]);
        System.out.println(arr1[2][1]);
        //调用外层元素
        System.out.println(arr1[0]);
        System.out.println(arr1[1]);

        arr3[0][1] = "Tom";
        System.out.println(arr3[0][1]);
        //3. 数组的长度
        System.out.println(arr1.length);
        System.out.println(arr1[1].length);

        //4. 遍历数组
        for (int i = 0; i < arr1.length; i++) {
            for (int j = 0; j < arr1[i].length; j++) {
                System.out.print(arr1[i][j]);

            }
            System.out.println();

        }
        System.out.println(Arrays.toString(arr1[1]));
        //5. 初始化值
        int[][] arr8 = new int[3][2];
        System.out.println(arr8[0]); //地址
        System.out.println(arr8[0][0]); //0
    }
}

案例:

//遍历二维数组中的元素，求和
public class TwoArrayTest {
    public static void main(String[] args) {
        //静态初始化
        int[][] arr1 = new int[][]{{3,5,8},{12,9},{7,0,6,4}};
        int sum =0; //记录总和
        for (int i=0;i<arr1.length;i++) {
            for (int j = 0; j < arr1[i].length; j++) {
                sum += arr1[i][j];
            }
        }
        System.out.println("总和为:"+sum);


    }
}

5.3 数组的常见操作（特征值统计、复制、反转、扩容与缩容、查找、排序）

5.3.1 数组的常见操作之特征值统计

//数组常见命令
public class ArrayCommonOperation {
    public static void main(String[] args) {
        //1. 动态初始化方式创建数组
        int[] arr1 = new int[10];
        //2. 通过循环给数组元素赋值
        for (int i=0;i<arr1.length;i++){
            arr1[i] = (int) (Math.random()*(99-10+1))+10;
            System.out.print(arr1[i]+" ");
        }
        System.out.println();
        //3. 求最大值
        int max = arr1[0];
        for (int i=1;i<arr1.length;i++){
            if (max<arr1[i]){
                max = arr1[i];
            }
        }
        System.out.println("最大值"+max);

        //4.求最小值
        int min =arr1[0];
        for (int i = 1; i < arr1.length; i++) {
            if (min > arr1[i]){
                min = arr1[i];
            }
        }
        System.out.println("最小值"+min);
        //5. 求和
        int sum =0;
        for (int i = 0; i < arr1.length; i++) {
            sum += arr1[i];
        }
        System.out.println("总和为:"+sum);

        //6. 求平均值
        int avgValue = sum / arr1.length;
        System.out.println("平均值为:"+avgValue);
    }
}

5.3.2 数组的常见操作之复制

//数组的复制
public class ArrayCopy {
    public static void main(String[] args) {
        //创建两个数组
        int[] arr1,arr2;
        //初始化数组
        arr1 = new int[]{2,3,5,7,11,13,17,19};
        //显示arr1
        for (int i = 0; i < arr1.length; i++) {
            System.out.print(arr1[i]+"\t");
        }
        System.out.println();
        //复制arr2等于arr1,修改偶索引使得值与下标相同
//        arr2 = arr1; 赋值
        arr2 = new int[arr1.length];  //通过遍历去复制
        for (int i = 0; i < arr1.length; i++) {
            arr2[i] = arr1[i];
        }
        //偶下标修改下标
        for (int i = 0; i < arr2.length; i++) {
            if(i%2==0){
                arr2[i] =i;
            }
            System.out.print(arr2[i]+"\t");
        }
        System.out.println();
        for (int i = 0; i < arr1.length; i++) {
            System.out.print(arr1[i]+"\t");
        }
    }
}

5.3.3 数组的常见操作之反转

//数组反转
public class ArrayRe {
    public static void main(String[] args) {
        // 定义一个arr数组
        int[] arr = new int[]{34,54,3,2,65,34,76};

        //遍历
        for(int i=0;i<arr.length;i++){
            System.out.print(arr[i]+"\t");
        }
        System.out.println();
        //反转操作
        //方法1
        for(int i=0;i<arr.length/2;i++){
            int temp = arr[i];
            arr[i] = arr[arr.length-i-1];
            arr[arr.length-i-1] = temp;
        }
        //遍历
        for (int i = 0; i < arr.length; i++) {
            System.out.print(arr[i]+"\t");
        }
        System.out.println();
        //方法2
        int[] arr2 = new int[arr.length];
        for (int i = 0; i < arr.length; i++) {
            arr2[i] = arr[arr.length-i-1];
            System.out.print(arr2[i]+"\t");
        }
        //方式3
        for (int i = 0,j =arr.length-1; i < j; i++,j--) {
            int temp = arr[i];
            arr[i] = arr[j];
            arr[j] = temp;
        }
        System.out.println();
        //遍历
        for (int i = 0; i <arr.length ; i++) {
            System.out.print(arr[i]+"\t");
        }
    }
}

5.3.4 数组的常见操作之扩容与缩容

//数组扩缩容
public class ArrayExpandReduce {
    public static void main(String[] args) {
        int[] arr1= new int[]{1,2,3,4,5};

        //扩容arr1
        int[] arr2 = new int[arr1.length<<1];
        for (int i = 0; i < arr1.length; i++) {
            arr2[i] = arr1[i];
        }
        //将10，20，30三个数据添加到新数组中
        arr2[arr1.length] = 10;
        arr2[arr1.length+1] = 20;
        arr2[arr1.length+2] = 30;

        String[] arr6 = new String[arr1.length<<1];
        String[] arr7 = new String[]{"1","3","9","f"};
        for (int i = 0; i < arr7.length; i++) {
            arr6[i] = arr7[i];
            System.out.print(arr6[i]+"\t");
        }
        System.out.println();

        for (int i = 0; i < arr2.length; i++) {
            System.out.print(arr2[i]+"\t");
        }
        //将新的地址赋值给arr1
        arr1 = arr2;
        System.out.println();
        for (int i = 0; i < arr1.length; i++) {
            System.out.print(arr1[i]+"\t");
        }
        System.out.println();


        //缩容
        int[] arr3= new int[]{1,2,3,4,5,6,7};
        int deleteIndex = 4;
        //复制一个arr3
        int[] arr5 = new int[arr3.length];
        for (int i = 0; i < arr3.length; i++) {
            System.out.print(arr3[i]+"\t");
            arr5[i] = arr3[i];
        }
        System.out.println();
        //缩 方式1
        for (int i = deleteIndex; i < arr3.length-1; i++) {
            arr3[i] = arr3[i+1];
        }
        //修改最后元素，设置默认值
        arr3[arr3.length-1] = 0;

        for (int i = 0; i < arr3.length; i++) {
            System.out.print(arr3[i]+"\t");
        }

        //缩 方式2
        //创建一个长度少一个的数组
        int[] arr4 = new int[arr5.length-1];
        for (int i = 0; i < deleteIndex; i++) {
            arr4[i] = arr5[i];
        }
        for (int i = deleteIndex; i < arr5.length-1; i++) {
            arr4[i] = arr5[i+1];
        }
        System.out.println();
        for (int i = 0; i < arr4.length; i++) {
            System.out.print(arr4[i]+"\t");
        }
    }
}

5.3.5 数组的常见操作之查找

//数组查找
public class ArraySearch {
    public static void main(String[] args) {
        int[] arr1 = new int[]{34,54,3,2,65,7,34,5,76,34,67};

        int target = 1;
//        target = 34;

        //方式1
        //查找方式:线性查找 执行效率低
        boolean isFlag = true;
        for (int i = 0; i < arr1.length; i++) {
            if(target == arr1[i]){
                System.out.println("找到了"+target+"，对应位置："+i);
                isFlag = false;
                break;
            }
        }
        if(isFlag){
            System.out.println("不好意思没有找到此元素！");
        }

        //方式2
        int i = 0;
        for (; i < arr1.length; i++) {
            if(target == arr1[i]){
                System.out.println("找到了"+target+"，对应位置："+i);
//                isFlag = false;
                break;
            }
        }
        if(i == arr1.length){
            System.out.println("不好意思没有找到此元素！");
        }

        //方式3
        //查找方式:二分法
        int[] arr2 = new int[]{2,4,5,8,12,15,19,26,37,49,51,66,89,100};
        target = 99;
//        target = 5;
        int head = 0; //默认首索引
        int end = arr2.length-1;  //默认尾索引
        boolean isFlag1 =false; //默认没有找到
        while(head<=end){
            int middle = (head +end)/2;
            if(target ==arr2[middle]){
                System.out.println("找到了"+arr2[middle]+",位置为:"+middle);
                isFlag1 = true;
                break;
            }else if (target>arr2[middle]){
                head = middle +1;
            }else{
                end = middle-1;
            }
        }
        if(!isFlag1){
            System.out.println("不好意思，未找到！");
        }
    }
}

5.3.6 数组的常见操作之排序

public class ArraySort {
    public static void main(String[] args) {
        //冒泡排序 bubble sort
        //遍历原数组
        int[] arr1 = new int[]{34,54,3,2,65,7,34,67};
        for (int i = 0; i < arr1.length; i++) {
            System.out.print(arr1[i]+"\t");
        }
        System.out.println();
        for (int i = 0; i < arr1.length; i++) {
            for (int j = 0; j < arr1.length-1-i; j++) {
                if(arr1[j]>arr1[j+1]){
                    int temp = arr1[j];
                    arr1[j] = arr1[j+1];
                    arr1[j+1] = temp;
                }
            }
        }
        System.out.println();
        for (int j = 0; j < arr1.length; j++) {
            System.out.print(arr1[j]+"\t");
        }
    }
}

6. 面向对象(Obiect Oriented Programming)

学习面向对象的三条主线

  • java类及类的成员:属性、方法、构造器；代码块、内部类
  • 面向对象的特征:封装、继承、多态、（抽象）
  • 其他关键字的使用:this、super、package、import、static、final、abstract等

面向对象编程有两个核心的概念：类（Class）、对象(Object)

  • 类:具有相同特征的事物的抽象描述，是'抽象的'、概念上的定义。
  • 对象:实际存在的该类事物的'每个个体'，是'具体的',因而也称为'实例(instance)'。

6.1 类的成员概述

面向对象程序设计的重点是类的设计
类的设计，其实就是类的成员的设计
类，是一组相关属性和行为的集合，也是类最基本的两个成员。

  • 属性:该类事物的状态信息。对应类中的成员变量
    • 成员变量<=>属性<=>Field
  • 行为:该类事物要做什么操作，或者基于事物的状态能做什么。对应类中的成员方法
    • 成员方法<=>函数<=> Method

面向对象完成具体功能的操作:

  • 步骤1:创建类，并设计类的内部成员(属性、方法)
  • 步骤2:创建类的对象。比如: Phone p1 = new Phone();
    • 格式:类类型 对象名 = new 对象实体;
  • 步骤3:通过对象，调用其内部声明的属性和方法，完成相关的功能
    案例:
public class Phone{
    //属性
    double price ; //价格
    String name;  //品牌
    //方法
    public void call(){
        System.out.println("手机能够拨打电话！");
    }
    public void sendMessage(String message){
        System.out.println("发送信息"+message);
    }
    public void playGame(){
        System.out.println("手机可以玩游戏");
    }
}

//面向对象 Object-Oriented Programming
//步骤 1.创建类，并设计类的内部成员（属性、方法）
//    2.创建类的对象 如：Phone p1 = new Phone[];
//    3.通过Phone的对象，调用其内部的属性何方法，完成相应的功能
public class BasicKnowledge {
    public static void main(String[] args){
        //创建Phone对象
        Phone p1 = new Phone();
        //通过Phone的对象，调用其内部声明的属性何方法
        //格式：”对象.属性“ ”对象.方法“
        p1.name = "huawei mate50";
        p1.price = 6999;
        System.out.println("name="+p1.name+",price="+p1.price);

        //调用方法
        p1.call();
        p1.sendMessage("有内鬼终止交易！");
        p1.playGame();

        //创建对象（类的实例化）
        Person p2 = new Person();
//        显示默认值
//        System.out.println("name = "+p2.name+",age = "+p2.age+",gender = "+ p2.gender);

        //通过对象去调用属性方法
        p2.name = "Tom";
        p2.age = 18;
        p2.gender = '男';

        System.out.println("name = "+p2.name+",age = "+p2.age+",gender = "+ p2.gender);

        //方法
        p2.eat();
        p2.sleep(8);
        p2.interests("画画");

        //在创建一个Person对象
        Person p3 = new Person();
        p3.name = "露丝";
        p3.age = 19;
        p3.gender = '女';
        System.out.println("name = "+p3.name+",age = "+p3.age+",gender = "+ p3.gender);
    }
}

6.1.1 类的成员之属性

属性的其他称谓：成员变量、属性、field、字段域
成员变量和局部变量的区别：
相同点：

  • 声明变量的格式相同:数据类型 变量名 = 变量值
  • 有作用域
  • 先声明再使用

不同点：

  • 类中声明的位置不同
    • 属性：声明在类内，方法外的变量
    • 局部变量：声明方法、构造器内部的变量
  • 在内存中的分配的位置不同
    • 属性：随着对象的创建，存储在堆空间中
    • 局部变量：存储在栈空间中
  • 生命周期
    • 属性：随着对象的创建而创建，随着对象的消亡而消亡
    • 局部变量：随着方法对应的栈帧，随着方法对应的栈帧出栈而消亡
  • 作用域
    • 属性：在整个类的内部有效
    • 局部变量：仅限于声明此局部变量所在的方法（或构造器、代码块）中
  • 是否可以有权修饰符进行修饰
    • 权限修饰符：public、protected、缺省、private
    • 属性：可以使用权限修饰符进行修饰
    • 局部变量：不能使用任何权限修饰符
  • 是否有默认值
    • 属性：都有默认初始化值
    • 局部变量：没有默认初始化值
    • 注意：针对方法的形参而言，在调用方法时，给此形参赋值即可。
      举例
public class Field {
    public static void main(String[] args) {
        Person1 p1 = new Person1();
        p1.age = 21;
        System.out.println(p1.age);
        p1.eat();
        p1.sleep(19);

    }
}

class Person1{
    //属性（成员变量）
    String name;
    int age;
    char gender;


    //方法
    public void eat(){
        String food = "宫保鸡丁"; //局部变量
        System.out.println("我喜欢吃"+food);
        System.out.println("name="+name);
    }
    public void sleep(int hour){ //形参:属于局部变量
        System.out.println("人不能小于"+hour+"小时的睡眠");
    }
}

public class Employee {
    //属性
    int id;  //编号
    String name;  //姓名
    int age;  //年龄
    double salary;  //薪资

}

//声明一个员工类Employee，包括属性：编号id，姓名name，年龄age，薪资salary
//声明一个EmployeeTest测试类，并在main方法中，创建两个员工对象，并为属性赋值，并打印两个员工信息
public class EmployeeTest {
    public static void main(String[] args) {
        //创建类的对象（创建类的实例，类的实例化）
        Employee emp1 = new Employee();
        System.out.println(emp1);  //类型@地址值
        emp1.id = 1001;
        emp1.age = 19;
        emp1.name = "小熙";
        emp1.salary = 2000;

        System.out.println("id="+emp1.id+"\tname="+emp1.name+"\tage ="+emp1.age+"\tsalary="+emp1.salary);

        //在创建一个Employee对象
        Employee emp2 = new Employee();
        emp2.id = 1002;
        emp2.age = 20;
        emp2.name = "小罗";
        emp2.salary = 2000;
        System.out.println("id = "+emp2.id+"\tname = "+emp2.name+"\tage = "+emp2.age+"\tsalary="+emp2.salary);
    }
}

6.1.2 类的成员之方法

方法是类或对象行为特征的抽象，用来完成某个功能操作。在某些语言中也被称为'函数'或'过程'。
方法的好处：实现代码的重用，减少冗余，简化代码
方法必须先声明再使用，定义在类的内部
方法中可以调用类中的方法或属性，不可以在方法内部定义方法

注意：

  • Java里的方法'不能独立存在',所有的方法必须定义在类里
  • Java中的方法不能调用，不执行。每调用一次，就执行一次
  • 方法内可以调用本类中的（其他）方法或属性
  • 方法内不能定义方法
//类成员之一:方法
/*
* 方法声明的格式:
* 权限修饰符 [其他修饰符] 返回值类型 方法名（形参列表）[throws 异常类型]{ //方法头
*    方法体
* }
* 权限修饰符:private 缺省 protected public (权限从小到大)
* 返回值类型:描述当调用完方式后，是否需要返回一个结果
*   分类:
*    无返回值类型:用void表示即可。比如:System.out.println(x)的println()方法
*    有返回值类型:基本数据类型 引用类型
* 方法名:见明知意，属于标识符
* 形参列表:属于局部变量，且可以声明多个。
*    格式:方法名（形参1,形参2...）
*return作用:1.结束方法的同时，用于返回数据给调用的者 2.结束方法
*
* 方法调用解析:
*   形参:方法在声明时，一对()内声明的一个或多个形式参数
*   实参:方法在被调用，实际传递给形参的变量或常量
* */
public class Method {
    public static void main(String[] args) {
        //好处:是类或对象行为特征的抽象，用来完成某个功能操作。
        //减少了代码冗余，简化代码，代码重用。
        Person p1 = new Person();
        p1.name = "荼茶";
        System.out.println(p1.name);

        System.out.println(p1.interests("羽毛球"));
    }
}


class Person{

    //属性
    String name;
    int age;

    //方法
    public void eat(){
        System.out.println("人吃饭");
    }
    public void sleep(int hour){
        System.out.println("人至少每天睡眠"+hour+"小时");
    }
    public String interests(String hobby){
        String info = "我的爱好是:"+hobby;
        System.out.println(info);
        return info;
    }
    public int getAge(){
        int age = 19;
        return age;
    }
}

public class Employee {
    //属性
    int id;  //编号
    String name;  //姓名
    int age;  //年龄
    double salary;  //薪资

    //定义一个方法，用于显示员工的属性信息
    public void show(){
        System.out.println("id="+id+"\tname="+name+"\tage ="+age+"\tsalary="+salary);

    }
}

//声明一个员工类Employee，包括属性：编号id，姓名name，年龄age，薪资salary
//声明一个EmployeeTest测试类，并在main方法中，创建两个员工对象，并为属性赋值，并打印两个员工信息
public class EmployeeTest {
    public static void main(String[] args) {
        //创建类的对象（创建类的实例，类的实例化）
        Employee emp1 = new Employee();
        System.out.println(emp1);  //类型@地址值
        emp1.id = 1001;
        emp1.age = 19;
        emp1.name = "小熙";
        emp1.salary = 2000;

        emp1.show();


        //在创建一个Employee对象
        Employee emp2 = new Employee();
        emp2.id = 1002;
        emp2.age = 20;
        emp2.name = "小罗";
        emp2.salary = 2000;
//        System.out.println("id = "+emp2.id+"\tname = "+emp2.name+"\tage = "+emp2.age+"\tsalary="+emp2.salary);

        emp2.show();
    }
}

封装了方法的例子
数组的常用算法，使用了类的方法

import java.util.Arrays;

/**
 * ClassName:CommonArrayOperations
 * Package:Method.Test
 * Description:
 *
 * @Author: pluto
 */
public class CommonArrayOperations {
    /**
     * 数组的常见操作
     * @param args
     */
    public static void main(String[] args) {
        CommonArrayOperations arrs = new CommonArrayOperations();
        int[] arr = new int[]{34,253,2354,87,98,64,2344,134,90};

        //求最大值
        System.out.println("最大值:"+arrs.getMax(arr));
        //求最小值
        System.out.println("最小值:"+arrs.getMin(arr));
        //求和
        System.out.println("求和:"+arrs.getSum(arr));
        //求平均值
        System.out.println("平均值:"+arrs.getAvg(arr));
        //打印
        arrs.print(arr);
        //排序
        arrs.sort(arr);
        System.out.println();
        System.out.println(Arrays.toString(arr));
        //查找
        System.out.println(arrs.search(arr, 90));
    }

    /**
     * 获取int[]数组的最大值
     * @param arr 要获取最大值的数组
     * @return  数组的最大值
     */
    public int getMax(int[] arr){
        int max = arr[0];
        for (int i = 0; i < arr.length; i++) {
            if(max<arr[i]){
                max = arr[i];
            }
        }
        return max;
    }

    /**
     * 获取int[]数组的最小值
     * @param arr 要获取最小值的数组
     * @return 数组的最小值
     */
    public int getMin(int[] arr){
        int min = arr[0];
        for (int i = 0; i < arr.length; i++) {
            if(min>arr[i]){
                min = arr[i];
            }
        }

        return min;
    }

    /**
     * 获取数据的和
     * @param arr 要获取和的数组
     * @return 数组的和
     */
    public int getSum(int[] arr){
        int sum =0;
        for (int i = 0; i < arr.length; i++) {
            sum += arr[i];
        }
        return sum;
    }

    /**
     * 获取数组的平均值
     * @param arr 要获取平均值的数组
     * @return  数组的平均值
     */
    public int getAvg(int[] arr){
        int avg = 0;
        avg = getSum(arr)/arr.length;
        return avg;
    }

    /**
     * 打印输出数组
     * @param arr 要打印的数组
     */
    public void print(int[] arr){
        System.out.print("[");
        for (int i = 0; i < arr.length; i++) {
            if (i ==0){
                System.out.print(arr[i]);
            }else{
                System.out.print(","+arr[i]);
            }
        }
        System.out.print("]");
    }

    /**
     * 复制数组
     * @param arr 要复制的数组
     * @return 数组的复制值
     */
    public int[] copy(int[] arr){
        int[] arr1 = new int[arr.length];
        for (int i = 0; i < arr.length; i++) {
            arr1[i] = arr[i];
        }
        return arr1;
    }

    /**
     * 获取数组的反转值
     * @param arr 要反转的数组
     */
    public void reverse(int[] arr){
        for (int i =0,j=arr.length-1; i <j; i++,j--) {
            int temp = arr[j];
            arr[j] = arr[i];
            arr[i] = temp;
        }
    }

    /**
     * 重新排序数组
     * @param arr 要排序的数组
     */
    public void sort(int[] arr){
        for (int i = 0; i < arr.length-1; i++) {
            for (int j = 0; j < arr.length-1-i; j++) {
                if(arr[j]>arr[j+1]){
                    int temp = arr[j+1];
                    arr[j+1] = arr[j];
                    arr[j] = temp;
                }
            }
        }
    }

    /**
     * 使用线性查找指定元素
     * @param arr 要查找的数组
     * @param choice  要查早的元素
     * @return choice在数组中的位置。若为找到，则返回-1
     */
    public int search(int[] arr,int choice){
        boolean isFlag = false;
        for (int i = 0; i < arr.length; i++) {
            if(choice ==arr[i]){
                isFlag = true;
                return i;
            }
        }
        //没有找到
        return -1;
    }
}

案例

public class Student {
    //属性
    int number; //学号
    int state;  //年纪
    int score;  //成绩

    //声明一个方法，显示学生的属性信息
    public String show(){
        return "学号:"+number+"年级:"+state+"分数:"+score;

    }
}


public class StudentUtil {
    /**
     * 根据指定年级打印学生信息
     * @param students 要打印的学生数组
     * @param state 指定的年级
     */
    public void printStudentWithState(Student[] students,int state){
        for (int i = 0; i < students.length; i++) {
            if(students[i].state==state){
                Student stu = students[i];
                System.out.println(stu.show());
            }
        }
    }

    /**
     * 打印学生数组
     * @param students 要打印的学生数组
     */
    public void printStudents(Student[] students){
        for (int i = 0; i < students.length; i++) {
            System.out.println(students[i].show());
        }
    }

    /**
     * 针对学生数组的成绩按照冒泡排序
     * @param students 要排序的数组
     */
    public void sortStudents(Student[] students){
        for (int i = 0; i < students.length-1; i++) {
            for (int j = 0; j < students.length-1-i; j++) {
                if(students[j].score>students[j+1].score){
                    Student temp = students[j];
                    students[j] = students[j+1];
                    students[j+1] = temp;
                }
            }
        }
    }
}


public class StudentTest {
    public static void main(String[] args) {
        //创建一个Student[]对象
        Student[] students = new Student[20];
        //循环，为数组赋值
        for (int i = 0; i < students.length; i++) {
            students[i] = new Student();
            //给每个学生对象的numder,state,score赋值
            students[i].number = i+1;
            students[i].state = (int) (Math.random()*6)+1;
            students[i].score = (int) (Math.random()*101);
        }
        //打印年纪为3的学生信息
        StudentUtil util = new StudentUtil();
        util.printStudentWithState(students,3);

        //使用冒泡排序按学生成绩排序，并遍历所有学生信息

        //排序前遍历
        util.printStudents(students);

        System.out.println("---------------------------");
        util.sortStudents(students);

        //排序后的遍历
        util.printStudents(students);

    }
}

6.1.2.1 方法的应用之重载

方法重载：在同一个类中，允许存在一个以上的同名方法，只要他们的参数列表不同即可
参数列表不同，意味着参数个数或参数类型的不同（包括顺序不同）。 两同一不同：同一类，相同方法名。参数列表不同。

public class OverLoad {
    //定义三个重载方法，方法名为mOL
    public void mOL(int num){
        System.out.println(num*num);
    }
    public void mOL(int num1,int num2){
        System.out.println(num1*num2);
    }
    public void mOL(String message){
        System.out.println(message);
    }

    //定义三个重载方法
    public int max(int num1,int num2){
        return (num1>num2)?num1:num2;
    }
    public double max(double d1,double d2){
        return (d1>d2)?d1:d2;
    }
    public double max(double d1,double d2,double d3){
        double tempMax = max(d1,d2);
        return max(tempMax,d3);
    }
}

6.1.2.2 方法的应用之可变个数形参

可变个数形参的方法在调用时，针对于可变的形参的实参的个数可以为：0个、1个或多个
可变个数形参的方法与同一类中，同名的方法之间可以构成重载
特例：可变个数形参的方法与同一类中方法名相同，且与可变个数形参的类型相同的数组参数不构成重载

格式：
+ （参数类型 ... 参数名）

public class VaribleArgument {
    public static void main(String[] args) {
        VaribleArgument test = new VaribleArgument();
        String info = test.concat("-","hello","男","World");
        System.out.println(info);
        System.out.println(test.concat("/"));
        System.out.println(test.concat("*"));
        System.out.println(test.concat("-"));
        System.out.println(test.concat("/","Hello"));
    }


    public String concat(String operator,String ... strs){
        String result = "";
        for (int i = 0; i < strs.length; i++) {
            if(i==0){
                result +=strs[i];
            }else{
                result +=(operator+strs[i]);
            }
        }
        return result;
    }
}

6.1.2.3 方法的应用之方法值传递机制的剖析

基本数据类型的变量，将变量保存的值传递出去
引用数据类型的变量，将变量保存的地址值传递出去

public class ValueTransferTest {
    public static void main(String[] args) {
        //1. 基本数据类型的局部变量

        int m = 10; 
        int n = m;
        System.out.println("m = "+m+"\t"+"n = "+n); // m=10 n =10

        m++;
        System.out.println("m = "+m+"\t"+"n = "+n); // m=11 n =10

        //2. 引用数据类型的局部变量
        //2.1 数组类型
        int[] arr1 = new int[]{1,2,3,4,5};
        int[] arr2 = arr1;

        arr2[0] = 10;
        System.out.println(arr1[0]); //10

        //2.2 对象类型
        Order order1 = new Order();
        order1.orderID = 1001;

        Order order2 = order1;
        order2.orderID = 1002;
        System.out.println(order1.orderID);  //1002

    }
}

class Order{
    int orderID;
}

案例

public class ValueTransferTest1 {
    public static void main(String[] args) {
        ValueTransferTest1 test = new ValueTransferTest1();

        //1. 对于基本数据类型的变量来说
        int m = 10;
        test.method1(m);

        System.out.println("m = "+m); //10


        //2. 对于引用数据类型的变量
        Person p = new Person();
        p.age = 10;

        test.method2(p);
        System.out.println(p.age); //11

    }


    public void method1(int m){
        m++;
    }
    public void method2(Person p){
        p.age++;
    }
}




public class ValueTransferTest2 {
    public static void main(String[] args) {
        int m = 10;
        int n = 20;
        ValueTransferTest2 test = new ValueTransferTest2();

        System.out.println("m = "+m+"，n = "+n);

//        //交换两个变量的值
//        int temp = m;
//        m = n;
//        n = temp;
        //调用方法
        test.swap(m,n);


        System.out.println("m = "+m+"，n = "+n);  // m=10 n=20
    }

    public void swap(int m,int n){
        int temp = m;
        m = n;
        n = temp;
    }
}



public class ValueTransferTest3 {
    public static void main(String[] args) {
        sort test = new sort();
        int[] arr = new int[]{34,12,67,99,87,54,32};
        System.out.println(test.sort(arr,"asc")); //升序
        System.out.println(test.sort(arr,"desc")); //降序
    }
}

class sort{
    public String sort(int[] arr,String sortMethod){
        if(sortMethod.equals("asc")){
            for (int i = 0; i < arr.length-1; i++) {
                for (int j = 0; j < arr.length-1-i; j++) {
                    if(arr[j]>arr[j+1]){
                        int temp = arr[j];
                        arr[j] = arr[j+1];
                        arr[j+1] = temp;
                    }
                }
            }
            return "升序后的数组"+ Arrays.toString(arr);
        }else if(sortMethod.equals(("desc"))){
            for (int i = 0; i < arr.length-1; i++) {
                for (int j = 0; j < arr.length-1-i; j++) {
                    if(arr[j]<arr[j+1]){
                        int temp = arr[j];
                        arr[j] = arr[j+1];
                        arr[j+1] = temp;
                    }
                }
            }
            return "降序后的数组"+ Arrays.toString(arr);
        }else{
            return "你输入的数组有误!";
        }
    }
}



import java.util.Arrays;

/**
 * ClassName:ValueTransferTest3
 * Package:Method
 * Description:
 *
 * @Author: pluto
 */
public class ValueTransferTest3 {
    public static void main(String[] args) {
        sort test = new sort();
        int[] arr = new int[]{34,12,67,99,87,54,32};
        System.out.println(test.sort(arr,"asc")); //升序
        System.out.println(test.sort(arr,"desc")); //降序
        System.out.println(test.sort(arr,"null")); //空指针解决办法

    }
}

class sort{
    public String sort(int[] arr,String sortMethod){
        if("asc".equals(sortMethod)){
            for (int i = 0; i < arr.length-1; i++) {
                for (int j = 0; j < arr.length-1-i; j++) {
                    if(arr[j]>arr[j+1]){
//                        int temp = arr[j];
//                        arr[j] = arr[j+1];
//                        arr[j+1] = temp;
                        swap(arr,j,j+1);

                    }
                }
            }
            return "升序后的数组"+ Arrays.toString(arr);
        }else if("desc".equals((sortMethod))){
            for (int i = 0; i < arr.length-1; i++) {
                for (int j = 0; j < arr.length-1-i; j++) {
                    if(arr[j]<arr[j+1]){
//                        int temp = arr[j];
//                        arr[j] = arr[j+1];
//                        arr[j+1] = temp;
                        swap(arr,j,j+1);
                    }
                }
            }
            return "降序后的数组"+ Arrays.toString(arr);
        }else{
            return "你输入的数组有误!";
        }
    }
    public void swap(int[] arr,int i,int j){
        int temp = arr[i];
        arr[i] = arr[j];
        arr[j] = temp;
    }
}

6.1.2.4 方法的应用之递归方法

递归方法调用：方法自己调用自己的现象称为递归

分类：

  • 直接递归：方法自身调用自己
public void methodA(){
	methodA();
}
  • 间接递归：理解为A（）方法调用B（）方法，B（）调用C（）方法，C()调用A（）方法
public void A(){
	B();
}
public void B(){
	C();
}
public void C(){
	A();
}

public class RecursionTest {
    public static void main(String[] args) {
        RecursionTest test = new RecursionTest();
//        test.method1();
        System.out.println(test.getSum(100));
        System.out.println(test.getSum1(100));
        System.out.println(test.getMul(5));

    }

    /**
     * 举例1：计算1-100内的自然数的总和
     */
    public int getSum(int num){
        int sum =0;
        for (int i = 0; i <= num; i++) {
            sum +=i;
        }
        return sum;
    }
    //使用递归
    public int getSum1(int num){
        if(num ==1){
            return 1;
        }else{
            return num + getSum1(num-1);
        }
    }

    /**
     * 举例2:计算n!
     */
    public int getMul(int n){
        if(n ==1){
            return 1;
        }else{
            return n * getMul(n-1);
        }
    }

    /**
     * 如下递归方法的调用，会导致StackOverflowError
     */
//    public void method1(){
//        System.out.println("method1()...");
//        method1();
//    }
}

案例：汉诺塔游戏

import java.util.Scanner;

public class HanoiTower {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        System.out.print("请输入汉诺塔的层数：");
        int n = scanner.nextInt();
        hanoi(n, 'A', 'B', 'C');
    }

    public static void hanoi(int n, char from, char to, char aux) {
        if (n == 1) {
            System.out.println("将第1个盘子从 " + from + " 移动到 " + to);
        } else {
            hanoi(n - 1, from, aux, to);
            System.out.println("将第" + n + "个盘子从 " + from + " 移动到 " + to);
            hanoi(n - 1, aux, to, from);
        }
    }
}

这个程序会要求用户输入汉诺塔的层数，然后调用 hanoi 方法进行求解。hanoi 方法是一个递归函数，它接受三个参数：盘子数量 n、起始柱子 from 和目标柱子 to，以及辅助柱子 aux。当 n 等于 1 时，直接将第一个盘子从起始柱子移动到目标柱子；否则，先将 n - 1 个盘子从起始柱子移动到辅助柱子，然后将第 n 个盘子从起始柱子移动到目标柱子，最后将 n - 1 个盘子从辅助柱子移动到目标柱子。在移动盘子时，程序会输出移动的过程，例如将第1个盘子从 A 移动到 B。
案例：快速排序

public class QuickSort {
    public static void main(String[] args) {
        int[] arr = {10, 7, 8, 9, 1, 5};
        quickSort(arr, 0, arr.length - 1);
        System.out.println(Arrays.toString(arr));
    }

    public static void quickSort(int[] arr, int low, int high) {
        if (low < high) {
            int pivot = partition(arr, low, high);
            quickSort(arr, low, pivot - 1);
            quickSort(arr, pivot + 1, high);
        }
    }

    public static int partition(int[] arr, int low, int high) {
        int pivot = arr[high];
        int i = low - 1;
        for (int j = low; j < high; j++) {
            if (arr[j] < pivot) {
                i++;
                int temp = arr[i];
                arr[i] = arr[j];
                arr[j] = temp;
            }
        }
        int temp = arr[i + 1];
        arr[i + 1] = arr[high];
        arr[high] = temp;
        return i + 1;
    }
}

这个程序会对一个整数数组进行快速排序，并输出排序后的结果。快速排序使用分治法的思想，将数组分成两个子数组，然后递归地对这两个子数组进行排序。具体实现中，使用 partition 方法将数组分成两个部分，然后将枢轴元素（pivot）放到它的最终位置上，使得左边的元素都小于枢轴元素，右边的元素都大于枢轴元素。然后对左右两个子数组分别进行递归排序。
斐波那契数列

public class Fibonacci {
    public static void main(String[] args) {
        int n = 10;
        for (int i = 0; i < n; i++) {
            System.out.print(fibonacci(i) + " ");
        }
    }

    public static int fibonacci(int n) {
        if (n <= 1) {
            return n;
        } else {
            return fibonacci(n - 1) + fibonacci(n - 2);
        }
    }
}

这个程序会输出斐波那契数列的前 n 个数。斐波那契数列中，第 0 个数为 0，第 1 个数为 1，后续的每个数都是前两个数之和。在实现中，使用递归函数 fibonacci 计算第 n 个数的值。如果 n 小于等于 1，直接返回 n；否则，返回 fibonacci(n - 1) + fibonacci(n - 2)。递归结束条件是 n 小于等于 1，因为此时已经到达了斐波那契数列的起始位置。

标签：总结,知识点,arr,JAVA,int,System,println,public,out
From： https://www.cnblogs.com/Pluto-Love-Learn/p/17382093.html

相关文章

  • JAVA的线程池随笔
    线程池基本概念概念：线程池主要是控制运行线程的数量，将待处理任务放到等待队列，然后创建线程执行这些任务。如果超过了最大线程数，则等待。优点：线程复用：不用一直new新线程，重复利用已经创建的线程来降低线程的创建和销毁开销，节省系统资源。提高响应速度：当任务达到时，不用创建新的......
  • 每日总结 5.9
    今日完成广告的判断处理，广告图片的闪烁切换，对弹出广告做出优化处理；<scripttype="text/javascript">vartime=10;//时间,秒vari=0;functiondis(){document.all.s.innerHTML=(time-i);i++;......
  • 5.9每日总结
    <?xmlversion="1.0"encoding="utf-8"?><LinearLayoutxmlns:android="http://schemas.android.com/apk/res/android"xmlns:tools="http://schemas.android.com/tools"android:layout_width="match_parent......
  • 学习JavaScript数据结构与算法 第八章
    八，字典和散列表8.3ES2015Map类ECMAScript2015新增了Map类。constmap=newMap();map.set('Gandalf','[email protected]');map.set('John','[email protected]');map.set('Tyrion','[email protected]');......
  • LSM 树 设计思想总结
    LSM树的设计思想很有意思。LSM树将对磁盘的随机写入转化为了磁盘友好型的顺序写（无论机械磁盘还是SSD，随机读写都要远远慢于顺序读写），从而大大提高了写性能。 1、怎么转化顺序写？核心就是在内存中维护一个有序的内存表（memtable），当内存表大于阈值的时候批量刷入磁盘，生成最新的S......
  • 学习JavaScript数据结构与算法 第七章
    7.集合7.4ESMAScript2015---Set类ECMAScript2015新增了Set类作为JavaScriptAPI的一部分。我们可以基于ES2015的Set开发我们的Set类。constset=newSet()set.add(1)console.log(set.values())//@iteratorconsole.log(set.has(1))console.log(set......
  • 2023.5.9每日总结
    packagewangzhan;importjava.sql.Blob;publicclassPd_stu{privateintid;privateStringname;privateStringsex;privateStringclasss;privateStringmajor;privateStringfaculty;privateStringpas;privateBlob......
  • 5.9号今日总结
    今天做了python的实验四代码如下:importrefromcollectionsimportCounterimportrequestsfromlxmlimportetreeimportpandasaspdimportjiebaimportmatplotlib.pyplotaspltfromwordcloudimportWordCloudheaders={"User-Agent":"Mozilla......
  • Method com/mysql/jdbc/JDBC4ResultSet.getObject(Ljava/lang/String;Ljava/lang/Clas
      mybatis-plus生成的日期类型默认是localdatetime，数据库是datetime，按道理转换应该可以，我又不想把实体类转换成date查看依赖<--locadate/locadatetime的时间依赖--><dependency><groupId>org.mybatis</groupId><artifactId>mybatis-ty......
  • Linux 处理CPU和内存参数的方式总结
    Linux处理CPU和内存参数的方式总结关闭NUMA,关闭透明大页比较简单的方法:vim/etc/default/grub在GRUB_CMDLINE_LINUX里面添加配置:transparent_hugepage=nevernuma=off修改后的配置为:GRUB_CMDLINE_LINUX="resume=/dev/mapper/uos-swaprd.lvm.lv=uos/rootrd.lvm.......

赞助商

阅读排行

网站主页关于我们联系我们网站地图

本网站内容转载自其他媒体，侵权联系[admin##ips99.com]。

Copyright © 2020-2023 IPS99 版权所有 IPS99