JavaSE基础知识

最新推荐文章于 2024-09-12 19:45:47 发布
最新推荐文章于 2024-09-12 19:45:47 发布
阅读量463 收藏 2
点赞数
文章标签： java 缓存 开发语言 java-ee 算法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/wfqiaodaima/article/details/125213606
版权

JavaSE基础知识

1. java数据类型:

​ 基本数据类型：byte（1字节）、short（2字节）、int（4字节）、long（8字节）、float(4字节)、double(8字节)、char(1字节)、boolean 4种整型、2种浮点型、1种字符型、1种用于表示真值的Boolean型。
​ 引用数据类型：除了基本数据类型以外的都是引用数据类型

类命名方式：大驼峰（首字母大写，如果有第二个单词，第二个单词首字母大写）

Java虚拟机总是从指定类中的main方法的代码开始执行，为了代码能够执行，在类的源文件中必须包含一个main方法。

定义变量语法格式： 数据类型 变量= 初始值。
变量： 见名知意，使用小驼峰命名法，如果一个变量包含多个单词,第一个单词首字母小写，其他单词首字母大写。

final关键字修饰的变量、方法和类各有什么特征？

修饰变量，变为常量，所修饰的值不可变；

修饰方法，方法不能重写；

修饰类，类不能重写，继承，重写

2. Scanner类

键盘缓存区： 是一个字节数组。里面存放的是用户输入的所有内容。 例如：100 hello world haha 你在做什么？ 200 400 true就是用户输入的，会存放到一个字节数组里。这个存东西的数组称作键盘缓存区。 一旦键盘缓存区里存入的有内容，就可以通过Scanner对象提取里面的内容。他提供一些列提取方法，可以把缓存区里的内容提取成你需要的类型。 但是如果缓存区里没有内容的话，程序会等待用户输入，用户输入完之后（按了回车之后），输入的内容就会进入缓存区。

第一步创建Scanner Scanner scanner = new Scanner(System.in);

第二部提取缓存区内容 int n = scanner.nextInt();//提取一个整数

double m = scanner.nextDouble();//提取一个浮点数

boolean b = scanner.nextBoolean();//提取一个boolean数据

String str = scanner.next();//提取一个单词。遇到空格会结束。

String str2 = scanner.nextLine();//提取一个字符串，遇到回车结束。可以认为是把缓存区内容全部读出来

例如：

case 4:
                System.out.print("你确定要退出吗? Y/N:");
                scanner.nextLine();  //一定要多写一个nextLine()  吃掉上一个回车
                String str = scanner.nextLine();
                if (str.equals("Y")) {
                    System.out.println("成功退出");
                } else {
                    menu();
                }

Scanner是一个定义好的封装类，在java.util包里
Scanner 的作用，从控制台或者或文件里，提取指定类型的数据
简单来说，可以把键盘输入的类型，读成整形，字符串，布尔型
创建参数的时候需要一个参数，这个参数是一个流对象，
把键盘缓存区里的内容以整型的方式提取出来。

3. Random类

Random类 随机数类 ，但是是一个伪随机类。

伪随机：看着随机，实际上不随机。
Random会根据seed(种子)，生成一个数列，只要种子不变，数列永远不变

java.util.Random random = new java.util.Random(100); //括号不加参数的话，按照系统时间作为种子
for (int i = 0; i < 10; i++) {
    int num = random.nextInt();//获取一个随机数，
    System.out.print(num + " ");
}

//输出结果：-1193959466 -1220615319 -951589224 -1279751870 1016840512 464282119 -2042061750 1785100857 -463255762 1327222584 

生成一个[min, max]的随机数  int n = r.nextInt(max - min + 1) + min

练习：

//产生5个[10, 80]之间的随机数，输出产生的数，并求出最大的随机数。
//随机产生5个[10, 80]之间的随机数，输出产生的数，并求出最小的数。

    public static void main(String[] args) {
        int max = 0;
        for (int i = 0; i < 5; i++) {
            Random random = new Random();
            int num = random.nextInt(70 + 1) + 10;
            System.out.println(num + " ");
            if (num > max) {
                max = num;
            }
        }

        System.out.println("max:" + max);
        int min = 100;   //初始值至少要比最大的值相等

        for (int i = 0; i < 5; i++) {
            Random random = new Random();
            int num = random.nextInt(70 + 1) + 10;
            System.out.println(num + "");
            if (min > num) ;
            min = num;
        }
        System.out.println("min:" + min);
    }

4. 分支语句

/*
	if语法格式1
	if(条件表达式){
		代码
	}
	如果条件表达式为真,才会执行大括号里面的代码,如果表达式为false,跳过大括号里面的内容
*/


/*
 * if的语法格式2
 * if(条件表达式){
 *   代码1
 * }else{
 *   代码2
 * }
 *
 * 如果条件表达式为true，执行代码1，如果表达式为false  执行代码2
 * */


//判断一个数是奇数偶数

	//方法一：
		Scanner scanner = new Scanner(System.in);
        System.out.println("请输入一个数：");
        int a = scanner.nextInt();
        if (a % 2 == 0) {
            System.out.println("该数是偶数");
        } else {
            System.out.println("该数是奇数");
        }

	//方法二：
	    /*
         *       按位与 &
         *       00000000 00000000 00000001
         *       00000000 00000000 00001111
         * ---------------------------------
         *       00000000 00000000 00000001
         *
         *       性能翻倍
         * */

        System.out.println("请输入一个数:");
        int i1 = scanner.nextInt();
        if ((i1 & 1) == 1) {    //按位与运算
            System.out.println("输入的数是奇数");
        } else {
            System.out.println("输入的数是偶数");
        }
	

	// if语法格式3
	/*
		if(条件表达式){
			代码1;
		}else if(条件表达式) {
			代码2;
		}else {
			代码3;
		}		
	*/
/*
         * 需求：根据考试成绩计算应该给与什么奖励：
         * 考试100分，奖励一架航拍遥控飞机；
         * 考试90分~99分，奖励游乐场玩一次；
         * 考试80分~89分，奖励玩具赛车一辆；
         * 考试70分~79分，奖励玩手机30分钟；
         * 考试70分以下，挨揍一顿。
         * */
        System.out.println("请输入一个数");
        Scanner scanner = new Scanner(System.in);
        int score = scanner.nextInt();
        if (score == 100) {
            System.out.println("奖励一架航拍遥控飞机");
        } else if (score > 90) {
            System.out.println("奖励游乐场玩一次");
        } else if (score > 80) {
            System.out.println("奖励玩具赛车一辆");
        } else if (score > 70) {
            System.out.println("奖励玩手机30分钟");
        } else {
            System.out.println("挨揍一顿");
        }

5. 循环

/*
    for(表达式1;表达式2;表达式3;){
    循环体;
    }
*/
for循环只有一种使用场景， 循环次数已知;
for循环的使用频率最高，达到80%

例题：

//1. 在控制台打印出所有的水仙花数。水仙花数：是一个三位数，水仙花数的个位、十位、百位数字的立方之和等于原数。

for (int l = 100; l < 999;l++){
    int i = l / 100;  //百位
    int j = l /10 %10; //十位   或者 l %100 /10
    int k = l % 10;   //个位
    if (i*i*i+j*j*j+k*k*k == l){
        System.out.println(l+"是水仙花数");
    }
}

 //2. 数7游戏。从1到100（不含100），如果数是7的倍数或者包含7输出“过”，否则输出数字本身。
        for (int z = 0;z < 100;z++){
            if (z % 7 == 0 || z % 10 ==7||z /10 == 7){
                System.out.print("过 ");
            }else {
                System.out.print(z+ " ");
            }
        }
        
//3. 输入一个整数，判断是几位数。

		//方法一
        System.out.println("请输入一个整数：");
        Scanner scanner = new Scanner(System.in);
        int i = scanner.nextInt();
        int sum =0;
        if (i==0){
            System.out.println("0是一位数");
        }else {
            while(i!=0){
                i = i / 10 ;
                sum++;
            }
            System.out.println(sum);
        }

		//方法二
        //输入一个整数
        System.out.println("输入一个整数");
        int j = scanner.nextInt();
        int count = 1;
        while (j/10!=0){
            j /=10;
            count++;
        }
        System.out.println(count);*/
            
    //4. 打印  	 @ 
                 @@@ 
                @@@@@ 
               @@@@@@@ 
            
       	int num = 4;  			//定义行数
        int paddingLeft = 15;	//左边距
        char symbol = '@';      //符号
        for (int i = 0; i < num; i++) {
            for (int j = 0; j < num - i - 1+paddingLeft; j++) {
                System.out.print(" ");
            }
            for (int k = 0; k < (i * 2 + 1); k++) {
                System.out.print(symbol);
            }
            System.out.println(" ");
        }


		//5. 百钱买百鸡
        /*
        * 我国古代数学家张邱建在《算经》中出了一道“百钱买百鸡”的问题，题意是这样的：
        * 5文钱可以买一只公鸡，3文钱可以买一只母鸡，1文钱可以买3只小鸡。
        * 现在用100文钱买100只鸡，那么各有公鸡、母鸡、小鸡多少只？请编写程序实现。
        * */

        int money = 100;
        int gongjimoney = 5;
        int mujimoney = 3;
        int xiaojimoney = 1;
        for (int gongjinum = 0;gongjinum <= 20;gongjinum++){
            for (int mujinum = 0;mujinum <= 33; mujinum++){
                for (int xiaojinum = 0;xiaojinum <= 100; xiaojinum += 3){
                    if ((gongjimoney*gongjinum + mujimoney*mujinum + xiaojimoney*xiaojinum/3 ==money) && (gongjinum+mujinum+xiaojinum==100)){
                        System.out.print("公鸡个数:" + gongjinum);
                        System.out.print("母鸡个数:" + mujinum);
                        System.out.print("小鸡个数:" + xiaojinum);
                        System.out.println();
                    }

                }
            }

        }

		/*
        * 4. 猜数字。产生1个[10, 30]的随机数，从键盘上输入你的猜测结果，
        * 如果猜测的数比随机数大，提示"你猜的数据大了"，如果猜测的数比随机数小，提示"你猜测的数据小了"，
        * 如果猜测的数和随机数一样大，提示"恭喜你猜对了"，
        * 计算出猜了几次才猜对。
        * */
        int count2 = 0;
        int i = random.nextInt(30-10+1)+10;
        System.out.println("随机数为"+i);
        int guessNum;
        do {
            Scanner scanner = new Scanner(System.in);
            System.out.println("请输入你猜测的数:");
            guessNum = scanner.nextInt();
            if (i > guessNum){
                System.out.println("你猜测的数据小了");
            }else if (i < guessNum){
                System.out.println("你猜的数据大了");
            }else {
                System.out.println("恭喜你猜对了");
            }
            count2++;
        } while (guessNum != i);
        System.out.println("你一共猜了"+count2+"次");

		/*
        * 5. 求1! + 2! + 3! + 4!的和是多少。
        * */
        int sum2 = 0;  //定义 和
        for (int k = 1;k <= 4;k++){      //从1开始
            int ret = 1;
            for (int j = 1; j <= k; j++) {
                ret *= j;
            }
            sum2 += ret;
        }
        System.out.println(sum2);

6. 一维数组

什么是数组？

数组是一个容器，用于存放相同数据类型的一组数据
数组不属于基本类型，属于引用类型

数组定义

数据类型[] 数组名 = 初始值

数组的初始化

  1. 动态初始化，创建数组的时候，只指定大小，不指定内容，内容由后期填充\

    没有指定内容，数组元素会有默认值，整数（byte,short,int,long）是0，小数(float,double)是0.0,布尔是false,字符是’0’(ASCII为0的字符)

int [] array = new int[5];
char [] chars = new char[5];
  1. 静态初始化，在创建数组的时候，就指定了元素的内容

注意：元素个数是由内容推断出来的 ------------不能既指定元素个数，又指定内容。

int arrays[] = new int[]{1,2,3,4,5};
int array2[] = {1,2,3,4,5};    //第二行是第一行得简写      静态初始化可以简写。

数组的输出：

System.out.println(arrays[2]);   //数组名[坐标]
System.out.println(arrays); 	 //输出数组名代表的是 系统开辟的 内存地址的起始地址。

数组的遍历：

for循环：

//数组遍历
for (int i = 0; i < array2.length;i++){
    System.out.print(array2[i] + " ");
}

数组的查找：

  • 方式一：遍历数组进行查找----顺序查找–适用于任何情况。
  • 方式二：折半查找（二分法查找）。-----------要求数组必须有序。

练习：

/*
 * 有一组数据 10，8，23，41，52，66，34，12。编写代码求出数组中的最大值。
 * */
int array[] = new int[]{10, 8, 23, 41, 52, 66, 34, 12};
int max = 0;
for (int i = 0; i < array.length; i++) {
    if (max < array[i]) {
        max = array[i];
    }
}
System.out.println("最大值为：" + max);

/*
 * 有一个具有10个int 数据的数组，数组中的每个元素都是[10, 100]之间的随机数。编写代码求出数组中的最大值，最大值下标。
 * */
Random random = new Random();
int max2 = 0;
int array2[] = new int[10];
for (int i = 0; i < 10; i++) {
    array2[i] = random.nextInt(15 - 10 + 1) + 10;
    System.out.print(array2[i] + " ");
}

for (int i = 0; i < 10; i++) {
    if (max2 < array2[i]) {
        max2 = array2[i];
    }
}
System.out.println();
for (int i = 0; i < 10; i++) {
    if (max2 == array2[i]) {
        System.out.print("下标：" + i + " ");
    }
}
System.out.println("最大值为：" + max2);

/*
 * 有一个包含10个元素的数组，每个元素的值在[10,30]之间，查找数组中是否包含18，如果有18，打印出值为18的元素的下标。
 * 如果没有18，打印“数组中不包含18”。
 * */

int array3[] = new int[10];
//记录是否包含18 ，假定不包含
boolean isContain = false;
for (int i = 0; i < array3.length; i++) {
    array3[i] = random.nextInt(30 - 10 + 1) + 10; //生成随机数组
    System.out.print(array3[i] + " ");   //输出随机数组
}
for (int i = 0; i < array3.length; i++) { //遍历数组
    if (array3[i] == 18) {     //判断数组元素是否有18
        isContain = true;
    }
}
if (isContain) {
    for (int i = 0; i < array3.length; i++) {
        if (array3[i] == 18) {
            System.out.print("index：" + i);
            System.out.println();
        }
    }
} else {
    System.out.println();
    System.out.println("不包含18");
}

/*
* 需求：有一组已经排好顺序的数据：5，13，19，21，37，56，64，75，80，88，92。编写代码查询数组中是否包含数据78，21，13。
    1。使用顺序查找
    2。使用折半查找。
* */
 boolean flag1 = false; //记录是否包含78
 for (int i = 0; i < arr.length; i++) {
      if (arr[i] == 78) {
           flag1 = true;
      }
 }
if (flag1) {
    System.out.println("包含78");
} else {
     System.out.println("不包含78");
}
//方法二：使用折半查找。
        int low = 0;
        int height = arr.length - 1;
        boolean target1 = false;
        while (low <= height) {
            int mid = (low + height) / 2;
            if (arr[mid] == 78) {
                target1 = true;
                break;
            } else if (arr[mid] > 78) {
                height = mid - 1;
            } else {
                low = mid + 1;
            }
        }
        if (target1) {
            System.out.println("包含78");
        } else {
            System.out.println("不包含78");
        }

数组的插入：

影响数组插入速度的核心因素是：插入位置，第二因素是数组长度。
如果在末尾插入数据，一次都不用移动,在下标为0的时候，移动次数是最多的。

数组的特点：查找特别快，增加、删除操作耗时。

查找的时候满足一个线性函数，因为数组在内存种是连续的存储空间，所以可以通过下标瞬间定位元素。

/*
	需求，创建一个数量为10的数组，前7个{35,22,17,41,72,29,10}，将66插入第一个
*/

int array[] = {35,22,17,41,72,29,10,0,0,0};
int num = 66;
int index = 1;

//倒着移动
for (int i = array.length-1; i > index; i--){
    array[i] = array[i - 1];
}
//插入数组
array[index] = num;
//遍历数组
for (int i = 0; i < array.length;i++){
    System.out.print(array[i]+" ");
}

数组删除：

/*
        创建一个数量为10的数组，前7个{35,22,17,41,72,29,10}，将素组下标为1的元素删除
*/
        int index = 1;
        int array[] = {35,22,17,41,72,29,10,0,0,0};
        for (int i = index ; i < array.length - 1; i++) {  //从index开始
            array[i] = array[i+1];
        }
        //把最后一个元素设为0
        array[array.length-1] = 0;
		//遍历数组
        for (int i = 0; i < array.length ; i++) {
            System.out.print(array[i] + " ");
        }

数组排序：

  1. 选择排序：

选择排序的写法很固定：

for(int i = 0; i < 数组名.length - 1; i++){

​ int index = i; //最小值坐标

 for(int j = i + 1; j < 数组名.length; j++){

​ if(数组名[j] < 数组名[index]){

​ index = j;

	 }

​ }

数据类型 temp = 数组名[i];

​ 数组名[i] = 数组名[index];

 数组名[index] = temp;

}

//选择排序
public static void main(String[] args) {
    int arr[] = {67,42,88,16,25,3};
    //外层循环控制趟数
    for (int i = 0; i < arr.length-1; i++) {
        int index = i;//最小值坐标
        int min = arr[i]; //假设第一个数最小
        //内层循环遍历数组，找到最小值下标
        for (int j = i + 1; j < arr.length; j++) {
            if (min > arr[j]) {  //如果发现更小的数
                index = j;       //更新min的值
                min = arr[j];     //更新index
            }
        }
        //交换元素
        int temp = arr[index];
        arr[index] = arr[i];
        arr[i] = temp;
    }
    for (int i = 0; i < arr.length; i++) {
        System.out.print(arr[i]+ " ");
    }

}

冒泡排序：

for(int i = 0; i < 数组名.length - 1; i++){

for(int j = 0; j < 数组名.length - 1 - i; j++){

	 if(数组名[j] > 数组名[j+1]){

​ 数据类型 temp = 数组名[j];

​ 数组名[j] = 数组名[j+1];

​ 数组名[j+1] = temp;

	 }

 }

}

int arr[] = {67,42,88,16,25,3};
//外层循环控制趟数
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;
        }
    }
}
for (int i = 0; i < arr.length; i++) {
    System.out.print(arr[i]+" ");
}

内存中堆和栈的概念：

地址存放在栈中，new出来的对象存放在堆中。

int arr[] = new int[4];

如上代码： = 为赋值运算符，先执行右边，后执行左边，

栈区用来存放局部变量，定义在方法体内的变量都是局部变量，包括方法的参数

7. 二维数组

java的二维数组和c语言的二维数组不同。
C语言里二维数组的内存空间是连续的。
Java中二维数组内存是不连续的。

二维数组的本质是： 一个存放了很多一维数组的数组。

初始化：

  1. 动态初始化：
int[][] arr= new int[3][4];  //三行四列
  1. 静态初始化
int [][] array= {{12,3,4,5},{1,3,4,5,7,34}};

二位数组的长度打印：

打印数组行数：

System.out.println(arr.length);

打印数组列数：

System.out.println(arr[1].length);

打印数组名字：

System.out.println(arr);  //二维数组的地址

二维数组的遍历：

for (int i = 0; i <array.length ; i++) {
     for (int j = 0; j < array[i].length; j++) {
          System.out.print(array[i][j]+ " ");
     }
   	 System.out.println();
}

练习题：

/*
        创建一个3行5列的二维数组，每个元素的取值范围是[30, 70]，求数组中的最大值以及最大值的下标、平均值、第四列的和、第二行的和。
*/
        Random random = new Random();
        int sum = 0;   //存放第四列的和
        int sum2 = 0;  //存放第二行的和
        int array[][] = new int[3][5];
        for (int i = 0; i < 3; i++) {
            for (int j = 0; j < 5; j++) {
                array[i][j] = random.nextInt(70-30+1)+30;
                System.out.print(array[i][j]+ " ");
            }
            System.out.println();
        }
        int max = 0;
        for (int i = 0; i < 3; i++) {
            for (int j = 0; j < 5; j++) {
                if (max < array[i][j]){
                    max = array[i][j];
                }
                if (j == 3){
                    sum +=array[i][j];
                }
                if(i ==1){
                    sum2 +=array[i][j];
                }
            }
        }
        System.out.println("max:"+ max);
        System.out.println(sum);
        System.out.println(sum2);
        System.out.println("avg= " + sum*1.0/array.length);
        System.out.println("avg=" + sum2*1.0/array[0].length);


        for (int i = 0; i < 3; i++) {
            for (int j = 0; j < 5; j++) {
                if (max == array[i][j]){
                    System.out.println("坐标为：[" + i +"," + j+"]");
                }
            }
        }

二维数组的排序：

 /*
     * 需求：创建一个3行5列的二维数组，每个元素的取值范围是[30, 70]，对第2列的数据按从小到大排序。
     * */
    Random random = new Random();
    int[][] array = new int[3][5];
    for (int i = 0; i < array.length; i++) {
        for (int j = 0; j < array[i].length; j++) {
            array[i][j] = random.nextInt(70 - 30 + 1) + 30;
            System.out.print(array[i][j] + " ");
        }
        System.out.println();
    }
    //可以把第二列想象成一个数组  (虚拟数组)
    //冒泡排序

    for (int i = 0; i < array.length -1; i++) {
        for (int j = 0; j < array.length -1 - i; j++) {
           if (array[j][1] >array[j+1][1]){
               int temp = array[j][1];
               array[j][1] = array[j+1][1];
               array[j+1][1] = temp;
           }
        }
    }
    System.out.println();
    for (int i = 0; i < array.length; i++) {
        for (int j = 0; j < array[i].length; j++) {
            System.out.print(array[i][j]+ " ");
        }
        System.out.println();
    }
}

8. 方法

什么是方法？

方法是具有特定功能的代码块；

简单的理解就是：把一段完整的代码，看成一个整体，并给这段代码起个名字，以后在用的时候，使用这个名字就相当于执行了这一段代码。

方法两个重要的特点： 封装（封装实现细节）， 重用。

方法必须先创建才可以使用，创建只需要进行一次，使用可以多次。
方法的创建过程称为方法的定义。

方法如何定义？

方法的书写位置： 类中 方法外

专业术语：方法不能嵌套定义

方法包含那些成分？

修饰符、返回类型、方法名（参数类型）{

​ 方法体

}

方法名的命名方式： 小驼峰命名法。

java中没有函数，因为java是纯面向对象的语言。

函数和方法的区别：

  • 函数是一个独立的存在，不依附于任何类。 函数在使用的时候，直接 函数名(实参) 即可调用。
  • 方法不能独立存在， 方法必须属于某一个类。

方法分为四类：

  • 无参无返回值 修饰符 void 方法名(){}
  • 无参有返回值 修饰符 返回值类型 方法名(){}
  • 有参无返回值 修饰符 void 方法名(参数列表){}
  • 有参有返回值 修饰符 返回值类型 方法名(参数列表){}
	有没有返回值决定了方法的运行结果能不能被拿到。
*  如果没有返回值，那么方法只是在执行一个功能，并没有任何内容返回给你。
*  如果有返回值，那么方法不但执行一个功能，还会返回一个执行结果。
*  尽量我们提供返回值。


如果一个方法有返回值，那么调用的时候可以有两个选择。
   * 第一：使用返回值（定义一个变量保存一下返回值）。
   * 第二：不使用返回值（直接调用方法，不定义变量接收返回值）。
   * 如果方法没有返回值，那么你想用结果都用不了！

还可以这么分类：

  • 系统方法： 系统提供好的一些类，这些类中已经有的方法，称为系统方法。
  • 自定义方法：根据需要自己写的方法

形参和实参：

形参：形式参数，出现在方法定义时，占位用的，再定义方法的时候，我们并不知道参数的值是多少，但是我们知道需要对参数进行使用
实参：实际参数,在调用方法的时候，实际传入的参数。
实参---->形参 是单向的值拷贝的过程。

代码：

public static void main(String[] args){
    //swap
    int x =10; int y =20;
     System.out.println("x="+x+" y="+y);   //x=10 y=20
     swap(x,y);                            //x:10 y:20     x:20 y:10
     System.out.println("x="+x+" y="+y);   //x=10 y=20
    
    //swap2
    int array[] = {10,20};
    System.out.println("交换之前：array[0]="+array[0]+",array[1]="+array[1]);//交换之前array[0]=10,array[1]=20
    swap2(array);
    System.out.println("交换之后：array[0]="+array[0]+",array[1]="+array[1]);//交换之后array[0]=20,array[1]=10
	
    //swap3
	int arr[] = new int[]{10,30};
    System.out.println("交换之前：array[0]="+arr[0]+",array[1]="+arr[1]);//交换之前：array[0]=10,array[1]=30
    swap3(arr[0],arr[1]);
    System.out.println("交换之后：array[0]="+arr[0]+",array[1]="+arr[1]);//交换之后：array[0]=10,array[1]=30
}

//交换两个值
public static void swap(int x ,int y){
    System.out.println("x:"+x+" y:"+y);
    int temp = x;
    x = y;
    y = temp;
    System.out.println("x:"+x+" y:"+y);
}
 //交换数组中的两个值
public static void swap2(int array[]){
    int temp = array[0];
    array[0] = array[1];
    array[1] = temp;
}
public static void swap3(int x,int y){
    int temp =x;
    x = y;
    y = temp;
}

总结：

如果实参是引用类型，那么数据会同步更新
如果实参是基本类型，那么数据不会同步更新

方法的重载和重写：

方法重载：在同一个类中，有两个或者更多的方法，具有相同的方法名，但是参数类型或者参数个数不相同， 这样的方法成为方法重载。
* 注意：方法重载只看方法名和参数，不看返回值
*   C语言不支持方法重载，有一系列求绝对值的函数
*   例如： abs(整数) fabs(小数) dabs(double)
* 有了方法重载，减少了开发者的记忆成本，解决了命名危机问题。
*
* 方法重写：在继承关系里，有一个父类，有一个子类，子类可以继承父类所有的属性和方法
* 如果子类不满足父类某个方法的实现，或者不满足子类的需求，子类可以在父类方法的基础上，重写父类方法

不定参数的方法：

  • 不定参数的方法，方法的参数个数是不定的，动态的。
  • 不定参数方法中， 最多只能定义一个不定参数
  • 在方法里， 固定参数写前面。不定参数写末尾，而且有且只能有一个不定参数。
public static void main(String[] args) {
    int result =  sum(2,34,4,5,6,72324,45);
    System.out.println(result);

    System.out.println(calculate("sum",1,23,4));
    System.out.println(calculate("leijia",1,3));
    System.out.println(calculate("leicheng",1,3));
    System.out.println(calculate("chengji",1,2,5,6));

    int array[] = {11,35,6,845,45,77,2,3};
    System.out.println(indexOfNum(array,2,5,3));
}

public static int sum(int x,int ...nums){
    int result = 0;
    for (int i = 0; i < nums.length;i++){
        result += nums[i];
    }
    return result;
}

public static int calculate(String option,int ...num){
    int result = 0;
    switch (option){
        case "sum":
            for (int i = 0; i < num.length; i++) {
                result += num[i];
            }
            break;
        case "leijia":
            for (int i = num[0]; i <= num[1]; i++) {
                result += i;
            }
            break;
        case "leicheng":
            result =1;
            for (int i = num[0]; i <= num[1]; i++) {
                result *= i;
            }
            break;
        case "chengji":
            result = 1;
            for (int i = 0; i < num.length; i++) {
                result *= num[i];
            }
    }
    return result;
}

public static int indexOfNum(int arr[],int offSet,int count,int num){
        //假定-1 没有找到
         int index = -1;
        for (int i = offSet; i <= offSet+count; i++) {
            if (num == arr[i]){
                index = i;
                break;
            }
        }
         return index;
    }

练习题：

public static void main(String[] args) {
    isLegal();
    System.out.println(getInput(3,9,"输入非法，请输入3-9之间的数(含)"));
    System.out.println("位数为"+weishu(0));
    System.out.println("位数为"+bitsOfNum(156423));
}

/*
 * 设计一个方法，获取用户输入的数据。要求用户必须输入0~9之间的数，如果不是，让用户重新输入，直到用户输入的内容合法。
 * */
public static int isLegal(){
    Scanner scanner = new Scanner(System.in);
    int num = 0;
    do {
        System.out.println("请输入0-9之间的数字");
        num = scanner.nextInt();
        if (num >=0 && num <= 9){
            System.out.println(num);
            break;
        }else {
            System.out.println("输入的内容不合法，请重新输入");
        }
    }while (true);
    return  num;
}

/*
设计一个方法计算数字是几位数。需要有参数和返回值，参数就是要计算位数的数字，返回值是位数
*/
public static int weishu(int num){
    int bits = 0;
    while (num!=0){
        num/=10;
        bits++;
    }
    return  bits;
}

public static int getInput(int min ,int max,String errorMessage){
    Scanner scanner = new Scanner(System.in);
    System.out.println("请输入"+min + "~" + max+"之间的数(含)");
    int num = scanner.nextInt();
    while(num > max || num < min){
        System.out.println(errorMessage);
        num = scanner.nextInt();
    }
    return num;
}

public static  int bitsOfNum(int num){
    int bits = 0;
    do {
        num /= 10;
        bits++;
    }while (num != 0);
    return  bits;
}

public static void main(String[] args) {
    System.out.println(countNum(1,100,7));
    printTriangle(5,'@',0);
    int array[] = {14,165,75,341,1,67,3,0};
    int arr[] = {1,4,5,6,7,9,11,14,56,77};
    printArr(bubbleSort(array));
    System.out.println();
    printArr(selectSort(array));
    System.out.println();
    System.out.println(binarySearch(arr,6));

}

/*
 * 设计一个方法，实现数7游戏，并调用方法测试结果是否正确。不要只能数7，实现数n游戏，n是一个0~9之间的数。
 * */
public static int countNum(int min,int max,int num){
    int count = 0;
    for (int i = min; i < max; i++) {
        if (i % num == 0 || i / 10 ==num||i % 10 == num) {
            System.out.print("过 ");
            count++;
        }else {
            System.out.print(i+" ");
        }
    }
    return  count;
}


public static  void printTriangle(int row ,char img,int paddingLeft){
    for (int i = 0; i < row; i++) {
        //打印空格
        for (int j = 0; j < row - i -1 + paddingLeft; j++) {
            System.out.print(" ");
        }
        //打印符号
        for (int j = 0; j < i *2 + 1; j++) {
            System.out.print(img);
        }
        System.out.println();
    }
}


//封装冒泡排序
public static int[] bubbleSort(int array[]){
    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;
            }
        }
    }
    return array;
}


//封装选择排序
public static int[]  selectSort(int array[]){
    for (int i = 0; i < array.length - 1; i++) {
        int index = i; //最小值下标
        int min = array[i];  //假设第一个最小
        for (int j = i; j < array.length ; j++) {

            if (min > array[j]) {  //如果发现更小的数
                index = j;       //更新min的值
                min = array[j];     //更新index
            }
        }
        //交换元素
        int temp = array[index];
        array[index] = array[i];
        array[i] = temp;
    }
    return array;
}

//封装打印数组
public static void printArr(int array[]){
    for (int i = 0; i < array.length; i++) {
        System.out.print(array[i]+ " ");
    }
}
//封装二分法
public static boolean binarySearch(int array[], int num){
    int low = 0;
    int high = array.length - 1;
    boolean isFind = false;
    while (low <= high){
        int mid = (low+high)/2;
        if (array[mid] == num){
            isFind = true;
            break;
        } else if (array[mid] > num) {
            high = mid -1;
        }else {
            low = mid + 1;
        }
    }
    return isFind;
}
王斐
关注
JAVASE基础知识详解
02-17
JAVASE基础知识详解
JavaSE基础知识点
m0_61779243的博客
05-27 603
Java基础知识点 知识点是自己整理的，适合初学者，手打有些可能出现些许错误，还请多多包涵并指出 1. 初识Java 什么是Java 2. 环境配置 JDK下载与安装教程 Java JDK环境变量配置 3. 常量&变量 常量 ​ 一个固定不变的值 ​ 整数型、浮点型、字符型、布尔型、字符串型 变量 ​ 就是一个用于存放数据的容器，一次只能存储一个值 ​ 语法1：先声明，再赋值 ​ int i ； ​ i = 10； ​ 语法2：声明时候直接赋值 ​ int i
javaSE基础学习
最新发布
2401_83307475的博客
09-12 1014
基本数据类型的变量在栈上分配内存，而引用数据类型的变量在栈上分配引用（指针），对象的具体信息存储在堆内存上。关键字：java语言自己用到的一些词，有特殊作用的，我们称之为关键字，如public、class、int、double。变量就是内存中的一块区域，可以理解成一个盒子，用来装一个数据的，变量中装的数据是可以被替换的。c 变量是从定义开始到}截止的范围内有效，同一个范围内，定义的多个变量，它们的名称不能一样。放在变量的后面，先拿变量的值进行运算，再对变量的值进行+1、-1 （先用在加）
Javase基础知识
BigBigmin的博客
12-26 310
Java 是由 Sun Microsystems 公司于 1995 年 5 月推出的 Java 面向对象程序设计语言和 Java 平台的总称
JavaSE 基础知识
weixin_53850894的博客
09-29 1237
本文将对Java的三大特性：封装、继承、多态进行简单的说明，涉及abstract、final、static、implements、extends……等关键字，主要对父类和子类的继承、方法的重载和重写进行详细的叙述。
JavaSE基础知识文档、源码
12-15
本资源是我自己复习巩固JavaSE知识所写，知识点比较全面。 抽象类、多态、io、多线程、数据结构和集合、参考图片、案例源码class、有零有整的知识点。 可能并不适用所有人，但希望对你有所帮助。 文档和源代码纯自己...
JavaSE基础知识笔记（上）
11-15
JavaSE基础知识笔记（上） JavaSE是Java语言的标准版，用于桌面应用的开发，是其他两个版本的基础。本笔记涵盖了JavaSE的基础知识，包括Java入门、环境变量、JDK和JRE、Java的主要特性、Java基础概念、计算机的存储...
JavaSE基础知识笔记（下）
11-15
JavaSE基础知识笔记 JavaSE基础知识笔记（下）中主要讲解了Java中的I/O流和File类的使用。 ### 一、java.io.File类 java.io.File类用于表示文件或目录，每个实例对应一个抽象路径。File类提供了多种构造方法来...
JavaSE基础知识思维导图
11-07
学习java，基础很重要，空闲时间细化了知识点，更好的理解基础知识
JavaSE基础知识梳理
怯桦的博客
04-27 585
一、基础知识： 1、JVM、JRE和JDK的区别： JVM(Java Virtual Machine):java虚拟机，用于保证java的跨平台的特性。 java语言是跨平台，jvm不是跨平台的。 JRE(Java Runtime Environment):java的运行环境,包括jvm+java的核心类库。 JDK(Java Development Kit):java的开发工具,包括...
全网最全JavaSE基础知识1
a1085653724的博客
04-13 553
Java基础数据类型和方法 首先Java语言和c++一样是一种面向对象的语言，并且Java中一切皆对象。 1.基础数据类型 java,c,c++是强类型语言（即定义一个变量一定要规定它的类型） java中的数据类型大体分为八大基本数据类型（都有默认值），如下： 数值型： 1.整数 byte<short<int<long 整型 int（当在类中或者主方法外定义int变量时，默认值为0，且占用4个字节，和操作系统无关，规定8个二进制位bit为一个字节byte） 声明变量 int
JavaSE基础知识总结
keyto1的博客
06-02 657
这篇文章是当初我培训javaSE时自己在学习的过程中的总结，当然对于文章内容自己所写的并不详细，当时只是把自己感觉不熟悉的地方做个总结，无论怎样也有个复习的作用，另外我推荐学习的过程中一定要勤做总结，善于思考。 JVM包含的细节:指令集 寄存器(和cpu有关的) 类文件的格式 栈 垃圾回收堆 存储区。 JDK在安装时为什么一般不装公共JRE：公共JRE会单独安装在系统的其他路径...
Javase基础知识总结
qq_51215835的博客
04-01 484
javase总结
javase基础知识点
洛雪
04-03 1621
switch(必须为整型或字符型){ case 1: break; case2: break; default: } (int)(math.random()*10)0_9 为什么分基本数据类型和对象（不是一切皆对象吗） 因为基本数据类型的包装类也为对象，基本数据类型存放在栈中，读写速度比堆快 为什么会有包装类呢，因为程序中某些数据可能
JavaSE基础知识汇总
一条小黑龙的博客
10-11 1198
包含Java从数据类型到类与对象，抽象类与接口，以及常用类的知识总结
javaSE基础知识总结
beststudent_的博客
05-05 2478
一、 运行JAVA程序 （1）在doc窗口下运行Java文件（已安装JDK） ①java的编译：Javac 文件名.java，产生一个.class文件（字节文件）。 注意：一个类只能产生一个class文件。 如果JAVA文件放在一个包里，需要加入包的储存路径。 例如：JAVA文件放在文件夹com文件夹中的bit文件夹中，则首先在程序内导入包，导入包的格式为（package com.bit;） 然后...
javaSE基础知识
liyumeialice的博客
02-13 146
1、String类用法 String() 创建一个内容为空的字符串对象 String(char[] char) 根据字符数据创建一个字符串对象 String(byte[] byte) 根据字节数据创建一个字符串对象 String(String str) 根据传入的字符串创建一个字符串对象 2、判断是否相同 Boolean equals(String s) 比较两个字符串内容是否相同，区分大小写 B...
javase基础知识
04-28
JavaSE（Java Standard Edition）是Java平台的标准版，提供了Java语言的核心库和基础功能。下面是一些JavaSE基础知识的介绍： 1. Java语言特性：Java是一种面向对象的编程语言，具有简单、可移植、安全、高性能等特点。它支持自动内存管理（垃圾回收）、异常处理、多线程等特性。 2. 数据类型：Java提供了基本数据类型（如整型、浮点型、字符型、布尔型）和引用数据类型（如类、接口、数组）。可以使用变量来存储和操作数据。 3. 控制流程：Java提供了条件语句（如if-else、switch）、循环语句（如for、while、do-while）和跳转语句（如break、continue）来控制程序的执行流程。 4. 类和对象：Java是一种面向对象的语言，所有的代码都必须定义在类中。类是对象的模板，对象是类的实例。可以使用类来创建对象，并通过对象调用类中的方法和访问类中的属性。 5. 继承和多态：Java支持继承机制，一个类可以继承另一个类的属性和方法。通过继承可以实现代码的重用和扩展。多态是指同一个方法在不同的对象上有不同的行为。可以通过方法重写和方法重载来实现多态。 6. 异常处理：Java提供了异常处理机制，可以捕获和处理程序中的异常。通过try-catch-finally语句块可以捕获异常并进行相应的处理，保证程序的稳定性和可靠性。 7. 输入输出：Java提供了丰富的输入输出功能，可以通过标准输入输出、文件操作、网络通信等方式进行数据的输入和输出。 8. 集合框架：Java提供了一套集合框架，包括List、Set、Map等接口和实现类，用于存储和操作数据集合。集合框架提供了高效的数据结构和算法，方便开发者进行数据处理。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

王斐

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值