Java学习笔记(1)

最新推荐文章于 2024-07-14 14:59:27 发布
最新推荐文章于 2024-07-14 14:59:27 发布
阅读量553 收藏 19
点赞数 17
文章标签： java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/2301_80132772/article/details/138276509
版权

Java学习笔记(一)

Java入门

04 常见的cmd命令

  • 盘符名称 + : :E:

  • dir:查看当前路径下的内容dir

  • cd目录：进入单级目录cd itheima

  • cd…：回退到上一级目录cd..

  • cd 目录1\目录2\ …：进入多级目录

  • cd\：回退到盘符目录

  • cls：清屏

  • exit：退出命令提示符窗口

Java基础概念

01-02 注释和关键字

注释：对代码进行解释说明，不会参与编译和运行，书写时不要嵌套

  • 单行注释：//注释信息
  • 多行注释：/*注释信息*/
  • 文档注释(学习阶段用不到)：/**注释信息*/

关键字：被java赋予了特定含义的英文单词

  • 特点：字母全部小写，代码中颜色加亮

03 字面量

类型：整数、小数、字符串、字符、布尔、空

类型说明
整数不带小数点的数字
小数带小数点的数字
字符串用双引号括起来的内容
字符用单引号括起来的内容
布尔布尔值，表示真假
空一个特殊的值，空值(null)

特殊字符：

符号作用
\t制表符，在打印的时候，把前面字符串的长度补齐到8或者8的整数倍。最少补一个，最多补八个
public class ValueDemo1{
	public static void main(String[] args){
		// 整数
		System.out.println(666);
		System.out.println(666);
		
		// 小数
		System.out.println(-3.71);
		System.out.println(1.93);

		// 字符串
		System.out.println("黑马程序员");
		System.out.println("尼古拉斯");

		// 字符
		System.out.println('男');
		System.out.println('女');

		// 布尔
		System.out.println(true);
		System.out.println(false);

		// 空
		// 细节:null不能直接打印，只能用字符串形式打印null
		System.out.println("null");

		// 制表符	
		System.out.println("name"+'\t'+"age");
		System.out.println("tom"+'\t'+"23");
	}
}

04 变量

定义格式：数据类型 变量名 = 数据值;

用法：

  • 输出打印
  • 参与计算
  • 修改记录的值

注意

  • java中同名变量不能重复定义

  • 一个变量只能存一个值

  • 一条语句可以定义多个变量

  • 变量使用前一定要赋值

  • 变量的作用域范围

public class VariableDemo1{
	public static void main(String[] args){
		int a = 10;
		System.out.println(a);
		int b = 20;
		System.out.println(a+b);

		a = 50;

		int c=100,d=200,e=300;
		System.out.println(c);
		System.out.println(d);
		System.out.println(e);
	}
}

08 数据类型

  • 基本数据类型：

    数据类型关键字内存占用
    整数byte、short、int、long1、2、4、8
    浮点数float、double4、8
    字符char2
    布尔boolean1

10 标识符

  • 定义：给类、方法、变量等起的名字

标识符命名规范

  • 由数字、字母、下划线和美元符($)组成
  • 不能以数字开头，不能包含特殊符号
  • 不能是关键字
  • 区分大小写

建议

  • 小驼峰命名法：方法、变量
    • 标识符是一个单词的时候，全部小写
    • 标识符由多个单词组成时，第一个单词首字母小写，其他单词首字母大写
  • 大驼峰命名法：类名
    • 标识符是一个单词的时候，首字母大写
    • 标识符由多个单词组成的时候，每个单词的首字母都大写

11 键盘录入

步骤

  • 导包：Scanner这个类在哪
  • 创建对象：表示我要开始用Scanner这个类了
  • 接收数据：开始干活
import java.util.Scanner;

public class ScannerDemo1{
	public static void main(String[] args){
		Scanner sc=new Scanner(System.in);
		System.out.println("请输入整数：");
		int i=sc.nextInt();

		System.out.println(i);
	}
}

运算符

01-03 算数运算符

运算符：对字面量或者变量进行操作的符号

表达式：用表达式把字面量或者变量连接起来，符合java语法的式子

符号作用
+加
-减
*乘
/除
%取模、取余

  • 在计算时，如果有小数参与，结果可能不精确

  • 整数操作只能得到整数，想要得到小数，必须有浮点数参与运算

  • 练习：获取一个三位数的各个位数

    • 公式：
      • 个位：数字%10
      • 十位：数字/10%10
      • 百位：数字/10/10%10
      • 千位：数字/10/10/10%10
      • 依此类推…

04-05 隐式转换和强制转换

  • 数字进行运算时，数据类型不一样不能运算，需要转成一样的，才能运算

类型转换的分类

  • 隐式转换(自动类型提升)
    • 把一个取值范围小的数据，转成取值范围大的数据
    • byte、short、char三种类型的数据在运算的时候，都会直接提升为int，然后再进行运算
    • 取值范围：byte<short<int<long<float<double
  • 强制转换
    • 如果把一个取值范围大的数据，赋值给取值范围小的变量，是不允许直接赋值的。如果要这样做就必须加入强制转换
    • 格式：目标数据类型 变量名 = (目标数据类型)被强转的数据;
    • 例子：double a =12.3; int b=(int)a;
    • 当要转换的数据过大时，可能出现错误(越界)

06 字符串和字符的加操作

字符串的"+"操作

  • 当"+“操作中出现字符串时，这个”+"是字符串连接符，而不是算术运算符。会将前后数据进行拼接，产生一个新的字符串
  • 连续的进行"+"操作符，从左到右逐个执行

字符相加

  • 相加之前，会按照ascii码表转换为数字再进行运算

07 自增自减运算符

符号作用
++变量的值加一
–变量的值减一

  • 参与计算时：写在前面先使用后操作，写在后面先操作后使用

  • 单独使用时：++和–是放在变量的前边还是后边，结果都一样

08 赋值运算符和关系运算符

赋值运算符

符号作用
=赋值
+=加后赋值
-=减后赋值
*=乘后赋值
/=除后赋值
%=取余后赋值

关系运算符

符号作用
==相等
! =不相等
>大于
<小于
>=大于等于
<=小于等于
  • 关系运算符的结果都是boolean类型，要么是true，要么是false

09 逻辑运算符

符号作用
&逻辑与，并且
|逻辑或，或者
^逻辑异或，相同为false，不同为true
!逻辑非，取反

10 短路逻辑运算符

符号作用说明
&&短路与结果与&相同，但是有短路效果
||短路或结果与|相同，但是具有短路效果
  • 短路效果：当左边的表达式能确定最终结果，那么右边就不用参与运行了
package com.itheima.arithmeticoperator;

import java.util.Scanner;

public class DuanluTest {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        int a=sc.nextInt();
        int b=sc.nextInt();
        boolean result = a == 6 || b == 6 || (a + b) % 6 == 0;
        System.out.println(result);
    }
}

11 三元运算符和运算符优先级

三元运算符

  • 格式：关系表达式?表达式1:表达式2;
  • 意义：先判断关系表达式，如果结果为真，则执行表达式1，结果为假，则执行表达式2

运算符优先级

判断和循环

01 流程控制语句

通过一些语句，控制程序的执行流程

  • 顺序结构(默认)
  • 循环结构
  • 分支结构

02 if第一种格式和注意事项

  • 格式：

    if(关系表达式){
    语句体;
}

  • 如果对布尔类型的变量进行判断，不要用==号

  • 在语句体内，如果只有一句代码，大括号可以省略不写，直接把变量写在小括号中即可

03 if的第二种格式

  • 格式

    if(关系表达式){
    语句体1;
}
else{
    语句体2;
}

  • 流程

    • 首先计算关系表达式的值
    • 如果关系表达式的值为true就执行语句体1
    • 如果关系表达式的值为false就执行语句体2
    • 继续执行后面的其他语句

04 if的第三种格式

  • 格式

    if(关系表达式1){
    语句体1;
}
else if(关系表达式2){
    语句体2;
}
	...
else{
	语句体n+1;
}

05 switch语句

  • 格式

    switch(格式){
    case 值1:
        
    case 值2:
        
        ...
    default:
    	语句体1;
        break;
}

  • 流程

    • 首先计算表达式的值
    • 依次和case后面的值进行比较，如果有相应的值，就会执行对应的语句，在执行过程中，遇到break就会结束
    • 如果所有case后面的值和表达式的值都不匹配，就会执行default里面的语句，然后结束整个switch语句

  • 注意

    • 表达式取值为byte、short、int、char，JDK5以后可以是枚举，JDK7后面可以是String
    • case后面的值不能重复
    • 在case的语句块最后添加break才会停止，否则一直执行到default前的语句

06 switch的扩展知识

  • default可以省略，但不建议

  • default一般写在最下方

  • switch新特性：JDK12后增加了一种新的格式，可以用于省略break语句

    switch(关系表达式){
    case 值1->{
        语句体1;
    }
    case 值2->{
        语句体2;
    }
        ...
    default ->{
            语句体n+1;
        }
}  //语句体中只有一句话的时候，可以省略大括号

循环和判断

07 循环语句-for

  • 格式

    for(int i=1;i<=10;i++){
    System.out.println("HelloWorld");
}

  • 流程

    • 1.执行初始化语句
    • 2.执行条件判断语句，如果是false，结束循环，如果是true，执行循环体语句
    • 3.执行条件控制语句
    • 4.返回第二步

09 循环语句-while

  • 格式

    初始化语句;
while(条件判断语句){
    循环体语句;
    条件控制语句;
}

  • for循环和while循环的对比

    • 相同：运行规则相同
    • 不同：
      • for循环中，控制循环的变量，因为归属for循环的语法结构中，在for循环结束后，就不能再次被访问到了
      • while循环中，控制循环的变量，对应while循环来说不归属其语法结构中，在while循环结束后，该变量还可以继续使用
      • for循环中：知道循环次数或者循环的范围
      • while循环中：不知道循环的次数和范围，只知道结束循环的条件

10 两道力扣算法题目和do-while循环

  • 回文数

    package tset;

import java.util.Scanner;

public class Test16 {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        int x = 121;
        int ans=x;
        int num=0;
        while(x!=0){
            int ge = x % 10;
            x /= 10;
            num=num*10+ge;
        }
        System.out.println(num);
        if(num == ans){
            System.out.println(ans+"是回文数");
        }
        else{
            System.out.println(ans+"不是回文数");
        }
    }
}

  • 求商和余数

    package tset;

public class Test17 {
    public static void main(String[] args) {
        int divided = 100;
        int divisor = 10;
        int count=0;
        while(divided>=divisor){
            divided-=divisor;
            count++;
        }
        System.out.println("余数为："+divided);
        System.out.println("商是："+count);
    }
}

do-while循环

  • 格式

    初始化语句;
do{
    循环体语句;
    条件控制语句;
}while(条件判断语句);
    • 特点先执行后判断

循环高级综合练习

01 无限循环和跳转控制语句

无限循环

  • for循环格式无限循环

    for(;;){
    System.out.println("学习");
}

  • while循环格式无限循环

    while(true){
    System.out.println("学习");
}

  • do-while循环格式无限循环

    do{
    System.out.println("学习");
}while(true);

  • 注意事项

    • 无限循环的下面不能再写其他代码了，因为循环不停止就无法执行下面的代码

跳转控制语句

  • continue语句
    • 跳过本次循环，进入下一轮循环
  • break语句
    • 结束整个循环，执行下面的语句

02 逢7过

package com.itheima05.www.test;

public class LoopTest1 {
    public static void main(String[] args) {
        for(int i=1;i<=100;i++){
            if(i%7==0||i%10==7||i/10%10==7){
                System.out.println("过");
                continue;
            }
            System.out.println(i);
        }
    }
}

03 平方根

package test;

import java.util.Scanner;

public class LoopTest2 {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        int number = sc.nextInt();
        for(int i=1;i<=number/2;i++){
            if(i*i==number){
                System.out.println(i+"是"+number+"的平方根");
                break;
            }
            if(i*i>number){
                System.out.println(i-1+"是"+number+"的平方根的整数部分");
                break;
            }
        }
    }
}

04 判断质数

package test;

import java.util.Scanner;

public class LoopTest3 {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        int number = sc.nextInt();
        boolean flag = true;
        for (int i = 2; i <= number - 1; i++) {
            if (number % i == 0) {
                System.out.println(number + "不是质数");
                flag = false;
                break;
            }
        }
        if (flag) {
            System.out.println(number + "是一个质数");
        }
    }
}

05 猜数字

package test;

import java.util.Random;
import java.util.Scanner;

public class LoopTest4 {
    public static void main(String[] args) {
        Random rand = new Random();
        Scanner sc = new Scanner(System.in);
        int number = rand.nextInt(10);
        while(true){
            int guess = sc.nextInt();
            if(guess == number){
                System.out.println("Yes");
                break;
            }
            else if(guess < number){
                System.out.println("too low");
            }
            else{
                System.out.println("too high");
            }
        }
    }

数组

01 数组的概述和静态初始化

数组

  • 数组定义：一种容器，可以用于存储同种数据类型的多个值

  • 数组容器在存储数据的时候，需要结合隐式转换考虑

    • 例如：int类型的数组容器(byte short int)

    • 例如：double类型的数组容器(byte short int long float double)

    • 建议容器的类型和存储的数据类型保持一致

定义格式

//格式1
数据类型[]=数组名;
//格式2
数据类型 数组名[];

数组的初始化

  • 初始化：就是在内存中，为数组容器开辟空间，并将数据存入容器中的过程
  • 分类：
    • 静态初始化
      • 简化格式：数据类型[]数组名={元素1,元素2,...}
    • 动态初始化

02 数组的元素访问

数组元素访问

  • 格式：数组名[索引];
  • 索引：也叫做下标、角标
  • 索引特点：从零开始，逐个+1递增
package com.array;

public class ArrayDemo2 {
    public static void main(String[] args) {
        int[] arr={1,2,3,4,5};
        int a=arr[0];
        System.out.println(a);
        System.out.println(arr[1]);

        //存储数据到数组中
        arr[0]=100;
        System.out.println(arr[0]);
    }
}

03 数组的遍历和三道练习

数组遍历

int[] a={1,2,3,4,5};
for(int i=0;i<a.length;i++){
    System.out.println(a[i]);
}

04 数组的动态初始化

动态初始化

  • 定义：初始化时只指定数组长度，由系统为数组分配初始值
  • 格式：数据类型[] 数组名=new 数据类型[数组长度];

动态初始化和静态初始化的区别

  • 动态初始化
    • 只明确元素个数，不清楚具体数值
  • 静态初始化
    • 需求中已经明确具体的数据

数组常见问题

  • 索引越界问题：最小索引为0，最大索引为数组长度-1

05 数组练习1

求最值

package test;

public class ArrayTest4 {
    public static void main(String[] args) {
        int[] a={1,2,3,4,5,6,7,8,9,10};
        int max = a[0];
        for(int i=0;i<a.length;i++){
            if(a[i]>max){
                max=a[i];
            }
        }
        System.out.println(max);
    }
}

06 数组练习2

求和

package test;

import java.util.Random;

public class ArrayTest5 {
    public static void main(String[] args) {
        int[] arr = new int[10];
        Random r = new Random();
        for(int i=0;i<arr.length;i++){
            int number=r.nextInt(100)+1;
            arr[i]=number;
        }
        int sum=0;
        for(int i=0;i<arr.length;i++){
            sum+=arr[i];
            System.out.print(arr[i]+" ");//将数组中数据打印在同一行上
        }
        System.out.println(sum);

        int avg=sum/arr.length;
        System.out.println(avg);
        int ans = 0;
        for(int i=0;i<arr.length;i++){
            if(avg>arr[i]){
                ans++;
            }
        }
        System.out.println("比平均数小的数字有"+ans+"个");
    }
}
将数据打印在同一行上

System.out.print(打印内容+"");

07 数组练习3

package test;
public class ArrayTest6 {
    public static void main(String[] args) {
        int[] arr={1,2,3,4,5};
        for(int i=0,j=arr.length-1;i<j;i++,j--){
            int temp=arr[i];
            arr[i]=arr[j];
            arr[j]=temp;
        }
        for(int i=0;i<arr.length;i++){
            System.out.print(arr[i]+" ");
        }
    }
}

数组练习4

打乱数组顺序

package test;

import java.util.Random;

public class ArrayTest7 {
    public static void main(String[] args) {
        Random rand = new Random();
        int[] arr={1,2,3,4,5};
        for(int i=0;i<arr.length;i++){
            int j = rand.nextInt(arr.length);
            int temp = arr[i];
            arr[i] = arr[j];
            arr[j] = temp;
        }
        for(int i=0;i<arr.length;i++){
            System.out.print(arr[i]+" ");
        }
    }
}

方法

02 最简单的方法定义和调用

最简单的方法定义和调用

  • 方法定义

    public static void 方法名(){
    方法体;
}

  • 方法调用

    方法名();

实例

package com.solution;

public class SolutionDemo2 {
    public static void main(String[] args) {
        girlFriend();
    }
    public static void girlFriend(){
        System.out.println("企鹅");
        System.out.println("自立");
        System.out.println("18");
    }
}

03 带参数的方法定义和调用

带参数的方法定义和调用

  • 方法定义

    public static void 方法名(参数类型 参数名,...){
    方法体;
}

  • 方法调用

    方法名(参数1,参数2,...)

  • 注意事项

    • 实参和形参的个数以及数据类型需要一一对应

实参和形参

  • 实参：方法调用中的参数
  • 形参：方法定义中的参数

04 带返回值方法的定义和调用

带返回值方法的定义和调用

  • 定义

    public static 返回值类型 方法名(参数){
    方法体;
    return 返回值;

  • 调用

    • 直接调用

    方法名(实参);

    • 赋值调用

    数据类型 变量名 = 方法名(实参);

// 比较两长方形的面积大小
package test;

public class Test3 {
    public static void main(String[] args) {
        compare(1.2,3.2,3,2);
    }
    public static double getArea(double x,double y){
        double area = x*y;
        return area;
    }
    public static void compare(double x1,double y1,double x2,double y2){
        double area1=getArea(x1,y1);
        double area2=getArea(x2,y2);
        if(area1>area2) {
            System.out.println("第一个长方形面积更大");
        }
        else{
            System.out.println("第二个长方形面积更大");
            }
        }
    }

05 方法小结

  • 方法不调用就不执行
  • 方法和方法之间是平级关系，不能互相嵌套定义
  • 方法的编写顺序和执行顺序无关
  • 方法返回值类型为void，表示该方法没有返回值，没有返回值的方法可以省略return语句不写，或者只写return

return关键字

  • 没有返回值可以不写，写了代表方法结束
  • 有返回值必须写

06 方法的重载

  • 重载：在同一个类中，方法名相同，参数不同。与返回值无关
  • 参数不同：个数不同、类型不同、顺序不同

07 方法的三个练习

数组最大数

package test;

public class Test6 {
    public static void main(String[] args) {
        int[ ]arr={1,5,7,3,8,10};
        int max=getMax(arr);
        System.out.println("最大值为:"+ max);
    }
    public static int getMax(int[] arr){
        int max=arr[0];
        for(int i=1;i<arr.length;i++){
            if(arr[i]>max){
                max=arr[i];
            }
        }
        return max;
    }
}

元素在数组中是否存在

package test;

public class Test7 {
    public static void main(String[] args) {
        int[ ] arr={1,5,8,12,56,89,34,67};
        boolean result=test(arr,35);
        System.out.println(result);
    }
    public static boolean test(int[] arr,int n) {
        for(int i=0;i<arr.length;i++){
            if(arr[i]==n){
                return true;
            }
        }
        return false;
    }
}

08 方法练习-拷贝数组

package test;

public class Test8 {
    public static void main(String[] args) {
        int[] arr={1,2,3,4,5,6,7,8,9};
        int[] copy=copyOfRange(arr,3,7);
        for(int i=0;i<copy.length;i++){
            System.out.print(copy[i]+" ");
        }
    }
    public static int[] copyOfRange(int[] src, int start, int end) {
        int[] newArr=new int[end-start];
        int index = 0;
        for(int i=start;i<end;i++){
            newArr[index]=src[i];
            index++;
        }
        return newArr;
    }
}

10 什么是基本数据类型和引用数据类型

基本数据类型

  • 变量中存储的是真实的数据
  • 数据值存储在自己的空间中
  • 特点：赋值给其他变量，赋的是真实的值

引用数据类型

  • 变量中存储的是地址值，自己空间中存储的是地址值

  • 引用：使用其他空间中的数据

  • 特点：赋值给其他变量，赋的是地址值

11 方法的值传递

方法传递基本数据类型的内存原理

  • 传递基本数据类型时，传递的是真实的数据，形参的改变，不影响实际参数的值(如int)
  • 传递引用类型数据时，传递的是地址值，形参的改变，影响实际参数的值(如int[])

12 综合练习-01~02

买飞机票

package test;

import java.util.Scanner;

public class Test9 {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        System.out.println("请输入机票原价(元):");
        int ticket=sc.nextInt();
        System.out.println("请输入当前月份：");
        int month=sc.nextInt();
        System.out.println("请输入当前购买的舱位 0 头等舱 1 经济舱：");
        int seat=sc.nextInt();
        ticket=test(ticket,month,seat);
        System.out.println("折扣后票价为"+ticket);
    }
    public static int test(int ticket,int month,int seat) {
        if (month >= 5 && month <= 10) {
            if (seat == 0) {
                ticket = (int) (ticket * 0.9);
            } else if (seat == 1) {
                ticket = (int) (ticket * 0.85);
            } else {
                System.out.println("没有这个舱位");
            }
        } else if ((month >= 1 && month <= 4) || (month >= 11 && month <= 12)) {
            if (seat == 0) {
                ticket = (int) (ticket * 0.7);
            } else if (seat == 1) {
                ticket = (int) (ticket * 0.65);
            } else {
                System.out.println("没有这个舱位");
            }
        }
        return ticket;
    }
}

找质数

package test;

public class Test10 {
    public static void main(String[] args) {
        int ans = 0;
        for(int i=101;i<=200;i++){
            boolean flag=true;
            for(int j=2;j<100;j++){
                if(i%j==0){
                    flag=false;
                    ans++;
                    break;
                }
            }
            if(flag) {
                System.out.println(i+"是质数");
            }
        }
        System.out.println("一共有"+ans+"个质数");
    }
}

03~04 开发验证码和数组元素的复制

开发五位验证码

package com.itheima.test.test;

import java.util.Random;

public class Test3 {
    public static void main(String[] args) {
        char[] chs = new char[52];
        for(int i = 0; i < chs.length; i++){
            if(i<=25){
                chs[i] =(char)(97+i);
            }else{
                chs[i]=(char)(65+i-26);
            }
        }
        String result="";
        Random r = new Random();
        for(int i=0;i<4;i++){
            int randomIndex = r.nextInt(chs.length);
//            System.out.println(chs[randomIndex]);
            result=result+chs[randomIndex];
        }
        int number=r.nextInt(10);
        result=result+number;
        System.out.println(result);
    }
}

数组元素的复制

package com.itheima.test.test;

public class Test4 {
    public static void main(String[] args) {
        int[] arr={1,2,3,4,5};
        int[] newArr=new int[arr.length];
        for(int i=0;i<arr.length;i++){
            newArr[i]=arr[i];
        }
        for(int i=0;i<arr.length;i++){
            System.out.print(newArr[i]+" ");
        }
    }
}

05 评委打分

package com.itheima.test.test;

import java.util.Scanner;

public class Test5 {
    public static void main(String[] args) {
        int[] scoreArr=test();
        int max=getMax(scoreArr);
        int min=getMin(scoreArr);
        int sum=getSum(scoreArr);
        for(int i=0;i<scoreArr.length;i++){
            System.out.println(scoreArr[i]);
        }
        System.out.println("最大值为"+max);
        System.out.println("最小值为"+min);
        int avg=(sum-max-min)/(scoreArr.length-2);
        System.out.println("最终得分为："+avg);
    }

    public static int getMax(int[] arr){
        int max=arr[0];
        for(int i=0;i<arr.length;i++){
            if(arr[i]>max){
                max=arr[i];
            }
        }
        return max;
    }

    public static int getMin(int[] arr){
        int min=arr[0];
        for(int i=0;i<arr.length;i++){
            if(arr[i]<min){
                min=arr[i];
            }
        }
        return min;
    }

    public static int getSum(int[] arr){
        int sum=0;
        for(int i=0;i<arr.length;i++){
            sum+=arr[i];
        }
        return sum;
    }

    public static int[] test() {
        int[] arr=new int[6];
        Scanner sc = new Scanner(System.in);
        for(int i=0;i<arr.length;){
            System.out.println("请输入评委"+(i+1)+"的打分：");
            int score=sc.nextInt();
            if(score>=0&&score<=100){
                arr[i]=score;
                i++;
            }else{
                System.out.println("成绩超出规定打分范围");
            }
        }
        return arr;
    }
}

06 数字加密和解密

//part1
package com.itheima.test.test;

public class Test6 {
    public static void main(String[] args) {
        int[] arr={1,9,8,3};
        for(int i=0;i<arr.length;i++){
            arr[i]=arr[i]+5;
        }
        for(int i=0;i<arr.length;i++){
            arr[i]=arr[i]%10;
        }
        for(int i=0,j=arr.length-1;i<j;i++,j--){
            int temp=arr[i];
            arr[i]=arr[j];
            arr[j]=temp;
        }
        int number=0;
        for(int i=0;i<arr.length;i++){
            number=number*10+arr[i];
        }
        System.out.println(number);
    }
}

//part2
package com.itheima.test.test;

public class Test7 {
    public static void main(String[] args) {
        //反向推导
        int number = 12345;
        int temp = number;
        int count=0;
        while(number!=0){
            number=number/10;
            count++;
        }

        int[] arr=new int[count];

        int index=arr.length-1;

        while(temp!=0){
            int ge=temp%10;
            temp=temp/10;  //注意
            arr[index]=ge;
            System.out.println(index);
            index--;
        }
        for(int i=0;i<arr.length;i++){
            System.out.print(arr[i]+" ");
        }
    }
}

解密

//part 1
package com.itheima.test.test;

public class Test8 {
    public static void main(String[] args) {
        int[] arr={8,3,4,6};
        for(int i=0,j=arr.length-1;i<j;i++,j--){
            int temp=arr[i];
            arr[i]=arr[j];
            arr[j]=temp;
        }
        for(int i=0;i<arr.length;i++){
            if(arr[i]>=0&&arr[i]<=4){
                arr[i]=arr[i]+10;
            }
        }
        for(int i=0;i<arr.length;i++){
            arr[i]=arr[i]-5;
        }
        int number=0;
        for(int i=0;i<arr.length;i++){
            number=number*10+arr[i];
        }
        System.out.println(number);
    }
}

07 抽奖的两种实现

优化前

package com.itheima.test.test;

import java.util.Random;

public class Test9 {
    public static void main(String[] args) {
        int[] arr={2,588,888,1000,10000};
        int[] newArr=new int[arr.length];
        Random r=new Random();
        for(int i=0;i<5;){
            int randomIndex=r.nextInt(arr.length);
            int prize = arr[randomIndex];
            //判断当前奖项是否存在，如果存在则重新抽取，如果不存在，就表示为有效奖项
            boolean flag=contains(newArr,prize);
            if(!flag){
                //把当前抽取到的奖项添加到newArr中
                newArr[i]=prize;
                //添加完毕后，移动索引
                i++;
            }
        }
        for(int i=0;i<newArr.length;i++){
            System.out.print(newArr[i]+" ");
        }
    }
    public static boolean contains(int[] arr,int prize){
        for(int i=0;i<arr.length;i++){
            if(arr[i]==prize){
                return true;
            }
        }
        return false;
    }
}

优化后

package com.itheima.test.test;

import java.util.Random;

public class Test10 {
    public static void main(String[] args) {
        //1.打乱奖池中所有奖项的顺序
        int[] arr={2,588,888,1000,10000};
        Random r=new Random();
        for(int i=0;i<arr.length;i++){
            int randomIndex=r.nextInt(arr.length);
            int temp=arr[randomIndex];
            arr[randomIndex]=arr[i];
            arr[i]=temp;
        }
        
        //2.遍历奖池
        for(int i=0;i<arr.length;i++){
            System.out.print(arr[i]+" ");
        }
    }
}

08 双色球彩票系统

package com.itheima.test.test;

import java.util.Random;
import java.util.Scanner;

public class Test11 {
    public static void main(String[] args) {
        int[] arr=createNumber();
        System.out.println("===================");
        for(int i=0;i<arr.length;i++){
            System.out.print(arr[i]+" ");
        }
        System.out.println();
        System.out.println("===================");

        int[] userInputArr=userInputNumber();
        int redCount=0;
        int blueCount=0;

        for(int i=0;i<userInputArr.length-1;i++){
            int redNumber=userInputArr[i];
            for(int j=0;i<arr.length-1;j++){
                if(redNumber==arr[j]){
                    redCount++;
                    break;
                }
            }
        }
        //判断蓝球
        int blueNumber=userInputArr[userInputArr.length-1];
        if(blueNumber==arr[arr.length-1]){
            blueCount++;
        }

        if(redCount==6&&blueCount==1){
            System.out.println("恭喜你，中奖1000万");
        }else if(redCount==5&&blueCount==1){
            System.out.println("恭喜你，中奖500万");
        }else if((redCount==4&&blueCount==1)||(redCount==5&&blueCount==0)){
            System.out.println("恭喜你，中奖3000");
        }else if((redCount==3&&blueCount==1)||(redCount==4&&blueCount==0)){
            System.out.println("恭喜你，中奖10");
        }else if((redCount==2&&blueCount==1)||(redCount==3&&blueCount==0)||(redCount==0&&blueCount==1)){
            System.out.println("恭喜你，中奖5");
        }else{
            System.out.println("谢谢参与，谢谢惠顾");
        }
    }

    public static int[] userInputNumber(){
        //创建一个数组用于添加用户购买的彩票号码
        int[] arr=new int[7];
        Scanner sc=new Scanner(System.in);
        //让用户输入红球号;
        for(int i=0;i<6;){
            System.out.println("请输入第"+(i+1)+"个红球号码:");
            int redNumber=sc.nextInt();
            //redNumber 在1~33 且不重复
            if(redNumber>=1&&redNumber<=33){
                boolean flag=contains(arr,redNumber);
                if(!flag){
                    arr[i]=redNumber;
                    i++;
                }else{
                    System.out.println("当前红球号码已存在，请重新输入：");
                }
            }else{
                System.out.println("当前红球号码超出范围");
            }
        }

        while(true) {
            System.out.println("请输入蓝球号码：");
            int blueNumber = sc.nextInt();
            if (blueNumber >= 1 && blueNumber <= 16) {
                arr[arr.length - 1] = blueNumber;
                break;
            } else {
                System.out.println("当前蓝球号码超出范围");
            }
        }
        return arr;
    }

    public static int[] createNumber(){
        int[] arr = new int[7];
        Random random = new Random();
        int index=0;
        while(index<6) {
            int redNumber=random.nextInt(33)+1;
            boolean flag=contains(arr,redNumber);
            if(!flag){
                arr[index++]=redNumber;
            }
        }
        int blueNumber=random.nextInt(16)+1;
        arr[arr.length-1]=blueNumber;
        return arr;
    }

    public static boolean contains(int[] arr, int target){
        for (int i = 0; i < arr.length; i++) {
            if(arr[i]==target){
                return true;
            }
        }
        return false;
    }
}

09 二维数组

  • 静态初始化：数据类型[][] 数组名=new int[][]{{元素1,元素2,...}，{元素1,元素2,...}};
package com.itheima.test.test;

public class TwoDimensionDemo1 {
    public static void main(String[] args) {
        int[][] a = new int[][]{{1,2,3},{4,5,6,7,8}};
        int[][] b = {{1,2,3},
                {4,5,6,7,8}
        };
        System.out.println(b[0][0]);
        System.out.println();
        for(int i = 0;i<b.length;i++){
            for(int j = 0;j<b[i].length;j++){
                System.out.print(b[i][j]+" ");
            }
            System.out.println();
        }
    }
}


package com.itheima.test.test;

public class TwoDimensionDemo2 {
    public static void main(String[] args) {
        int[][] arr = new int[3][5];
        arr[0][0]=10;
        for(int i=0;i<arr.length;i++){
            for(int j=0;j<arr[i].length;j++){
                System.out.print(arr[i][j]+" ");
            }
            System.out.println();
        }
    }
}
  • 练习案例
package com.itheima.test.test;

public class Test13 {
    public static void main(String[] args) {
        int[][] arr={{22,66,44},
                {77,33,88},
                {25,45,65},
                {11,66,99}
        };
        int yearSum=0;
        for(int i=0;i<arr.length;i++){
            int[] quarterArr=arr[i];
            int sum=getSum(quarterArr);
            System.out.println("第"+(i+1)+"个季度的总营业额为："+sum);
            yearSum+=sum;
        }
        System.out.println("全年总营业额为："+yearSum+"元");
    }

    public static int getSum(int[] arr){
        int sum=0;
        for(int i=0;i<arr.length;i++){
            sum+=arr[i];
        }
        return sum;
    }
}

面向对象

02 类和对象

类：是共同特征的描述(设计图)

对象：是真实存在的具体案例

  • 定义类：

    public class 类名{
    1.成员变量
    2.成员方法
    3.构造器
    4.代码块
    5.内部类
}

  • 创建对象

    类名 对象名 = new 类名();

  • 使用对象

    • 访问属性：对象名.成员变量
    • 访问行为：对象名.方法名(…)

注意事项

  • 用来描述一类事物的类，专业称为Javabean类，在Javabean类中，不写main方法
  • 在以前，编写main方法的类，叫做测试类，我们可以在测试类中创建javabean类的对象并进行赋值调用
  • 类名首字母建议大写
  • 一个Java文件中可以定义多个class类，但建议一个文件定义一个类
  • 成员变量定义的完整格式为：修饰符 数据类型 变量名称 = 初始化值;一般无需指定初始化值，存在默认值
siix7en
关注
  • 17
    点赞
  • 踩
  • 19
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
java学习笔记1
09-20
Java学习笔记1 Java学习笔记1是学习Java过程中的笔记，主要记录了Eclipse开发环境中的快捷键使用、编辑功能、查找和调试等知识点。 Eclipse快捷键 Eclipse中有许多快捷键，掌握这些快捷键可以大大提高开发效率。...
我的java学习笔记1
07-31
这份"我的java学习笔记1"很可能包含了初学者在接触Java时会遇到的基础概念和关键知识点。下面，我们将深入探讨Java的一些核心特性以及可能在笔记中涉及的内容。 1. **Java简介**：Java是由Sun Microsystems公司（现...
Java学习笔记
Piglett的博客
12-30 893
随着后续的学习还会不断地更新，并不仅仅包含Java基础，后续还会更新SSM，MySQL等内容。其记录了Java基础的学习内容，主要包括24集合到30动态代理（见语雀目录）。希望这篇笔记能够帮助到Java的学习，方便快速进行回顾复习。
Java 学习笔记
weixin_42098295的博客
05-13 1979
Java 是一种面向对象的编程语言，广泛应用于开发各种应用程序，包括 Web 应用程序、桌面应用程序、移动应用程序和嵌入式系统。Java 中有八种基本数据类型：byte、short、int、long、float、double、char 和 boolean。集合用于存储和组织数据。Java 中有各种控制流语句，用于控制程序流程，例如 if-else 语句、switch 语句和循环语句。Java 中有各种运算符，用于执行算术运算、比较运算、逻辑运算和位运算。I/O 用于从文件、网络和其他来源读取和写入数据。
java学习笔记（持续更新）
快乐学习，daydayup!
12-24 7538
如果您也在学习java，希望能够和您一起讨论，一起学习。这篇文章是记录笔者0基础学习java的过程，如果您阅读这篇文章时，发现一些错误，也希望您愿意指出。本次java学习流程以黑马程序员的java教学视频为主，其他博主或公开教程为辅。学习过程中遇到的一些个别情况或错误都会记录其中并记载解决方案。本篇学习记录会一直更新，希望能与大家一起学习，共同成长。
JAVA学习笔记：目录
任性的生鱼片 的博客
12-28 1965
目录 java学习笔记1：了解java、JDK、JRE、JVM java学习笔记2：JDK下载和安装以及测试控制台测试是否配置成功 java学习笔记3：用记事本写第一个java程序，第一个java程序常见错误总结，第一个java程序详细解析 java学习笔记4：常见的DOS命令和java开发工具 java学习笔记5：eclipse的下载及使用，以及java程序的运行 java学习笔记6：注释、标识...
Java 学习笔记：面向对象
Li__Daxia的博客
03-19 1021
Java 学习笔记：面向对象
Thinking in Java读书笔记
热门推荐
yjclsx的博客
07-31 42万+
Thinking in Java读书笔记（IO和并发除外） 1.1、类中所有的private方法都隐式地指定为final的，由于其他类无法取用private方法，所以也就无法覆盖它；private方法无法被重写，继承对应private的方法无效，private的属性也无法拿到，但我们通常private的属性有对应的get、set方法，通常是public的，所以子类继承后可以调用方法来取得到父类的...
JAVA学习笔记（韩顺平老师）
2301_77385325的博客
04-19 1769
说明：本文为韩顺平老师的JAVA课程学习笔记，仅供自身学习参考，如有纰漏，请多指教，如有帮助，不胜荣幸。
Java学习路线总结，搬砖工逆袭Java架构师
学Java，找哪吒
09-07 24万+
定期分享Java硬核技术干货、分享Java学习路线、分享Java经典面试题
Java学习笔记一
u013033706的博客
10-23 1477
Java学习笔记一1、Java语言的特点2、Java程序开发过程3、Java虚拟机JVM 学习方式： 书籍：《Java基础教程》 吴仁群 清华大学出版社 1、Java语言的特点 一种面向对象且与平台无关的多线程动态语言 2、Java程序开发过程 文件名.java产生applicationapplets源文件编辑器Java编译器字节码文件由Java解释器执行由Web浏览器执行 图1 Java程...
JAVA学习笔记- - - day 1
m0_71956038的博客
11-18 6万+
目录💕前言：作者是一名正在学习JAVA的初学者，每天分享自己的学习笔记，希望能和大家一起进步成长💕​编辑运算符(重要)运算符四则运算基本数据类型变量间的运算赋值运算符比较运算符逻辑运算符(重要)流程控制(重要)1.if2.if...else...3.if...else if...else4.switch 只能做等值判断5.三元运算符6.循环结构while 先判断在做循环do...while 先循环在做判断for循环break面向对象面向过程面向对象类的属性类的方法创建对象的内存结构局部变量成员变量匿名对
java学习笔记总结
04-02
这份“java学习笔记总结”涵盖了作者在深入学习Java过程中积累的知识点和实践经验，旨在帮助读者理解和掌握Java的核心概念。 首先，Java的基础部分包括语法、变量、数据类型、运算符和流程控制。Java支持八种基本...
Java基础 学习笔记 Markdownr版
06-27
本学习笔记主要涵盖了Java的基础知识，包括面向对象、集合、IO流、多线程、反射与动态代理以及Java 8的新特性等方面，旨在帮助初学者或有经验的开发者巩固和提升Java编程技能。 1. 面向对象（OOP）：Java的核心是...
JAVA学习笔记1
11-17
JAVA语言学习路上的笔记1，通过实际结合总结
配置Java开发环境
Broken_x的博客
07-10 1526
Java开发环境配置
java版的上门家政系统和PHP版的上门家政有什么区别？
baina666的博客
07-12 504
综上所述，Java版和PHP版的上门家政系统各有优缺点，选择哪种语言主要取决于项目的具体需求、预算、开发团队的技术栈以及未来的扩展计划等因素。同时，由于Java生态系统的复杂性和多样性，也可能需要投入更多的时间和资源来学习和掌握相关的技术和工具。Java版：Java拥有庞大的生态系统和丰富的第三方库，这为家政系统的开发和扩展提供了强大的支持。Java版：由于Java的编译执行机制和高效的垃圾回收算法，Java版家政系统通常具有更高的运行效率和更好的性能表现，尤其是在处理高并发、大数据量等复杂场景时。
Spring Security 授权
最新发布
persistence_PSH的博客
07-14 680
在 loadUserByUsername 方法，在查询数据库用户信息的时候，同时查询出用户的权限，这里以角色名代指权限。在 loadUserByUsername 方法，在查询数据库用户信息的时候，同时查询出用户的权限，这里以角色名代指权限。在 loadUserByUsername 方法，在查询数据库用户信息的时候，同时查询出用户的权限，这里以角色名代指权限。通过 RBAC 获取到用户的具体权限后，再通过 Security 的 用户-权限-资源 来进行权限控制。HttpSecurity 权限配置。
【Go系列】 Sync并发控制
u013379032的博客
07-14 609
在上一篇文章中，我们介绍了goroutine和channel，理论上，通过channel可以实现并发控制，但是其他语言的开发者可能更习惯一些原子操作的库。当然Go语言也会提供这样的库，所以我们今天了解一下sync库。
JAVA学习笔记整理(全)
06-03
目录 JAVA 1 一、 基础语法 1 二、 MYSQL 33 三、 Nginx 60 四、 Redis 67 五、 Mybatis 75 六、 Spring 77 七、 Docker 84 八、 计算机网络 86 九、 JVM 96 十、 Springboot 111 十一、 RabbitMQ 112 十二、 其它 115 十三、 操作系统 126 十四、 数据结构 133 十五、Linux 133

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值