JavaSE 知识学习

置顶 已于 2022-12-12 03:27:31 修改
阅读量1k 收藏 4
点赞数 2
文章标签： 学习 java 开发语言 idea
于 2022-11-20 17:29:44 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/yyds_it_huo/article/details/127913725
版权

一、初识Java

1.1 Java语言概述

Java语言发展史

詹姆斯•高斯林（James Gosling）1977年获得了加拿大卡尔加里大学计算机科学学士学位，1983年 获得了美国卡内基梅隆大学计算机科学博士学位，毕业后到IBM工作，设计IBM第一代工作站NeWS系统，但不受重视。后来转至Sun公司，1990年，与Patrick，Naughton和Mike Sheridan等人合作“绿色计划”，后来发展一套语言叫做“Oak”，后改名为Java。
JDK的历史(Java Development Kit)

  • 1.0 - 1.1 - 1.2 - 1.3 - 1.4 - 1.5
  • 5.0 - 6.0 - 7.0 - 8.0……
  • Sun公司于1995年推出
  • 1991年sun公司James Gosling等人开始开发Oak语言
  • 1994年，将Oak语言更名为Java
  • 1996年获得第一笔投资1亿元
  • 1998年提出jdk1.2【GUI】
  • 之后推出jdk1.3 jdk1.4【反射】
  • 2005年重新更名为jdk5.0，进行了大幅的版本改进
  • 2006年sun公司宣布将Java作为免费软件对外发布
  • 2007年3月起，全世界所有的开发人员均可对Java源代码进行修改
  • 2007年推出jdk6.0
  • 2009年4月Oracle以74亿美元收购了sun公司
  • 2011年7月由Oracle正式发布jdk7
  • 2014年3月正式发布了java8
  • 2017年9月正式发布了java9【短期支持】
  • 2018年3月正式发布了java10【短期支持】
  • 2018年9月正式发布了java11
  • 1.8是企业主流使用的版本【LTS版本-longTimeService版本】

Java语言平台版本

  1. J2SE/JAVASE — Standard Edition—标准版/基础版
    开发普通桌面和商务应用程序提供的解决方案，该技术体系是其他两者的基础。
  2. J2EE/JAVAEE — Enterprise Edition— 企业版/商务版
    是为开发企业环境下的应用程序提供的一套解决方案，主要针对于企业级应用程序开发。
  3. J2ME/JAVAME — Micro Edition — 微型版/移动版
    是为开发移动设备和嵌入式设备(电器、机器人、机顶盒…)提供的解决方案。Java不是不侧重，而是分支出安卓。

Java语言特性

简单性 安全性 面向对象 高性能 编译性 解释性 分布式处理 健壮性 开源 跨平台
什么是跨平台性？
通过Java语言编写的应用程序在不同的系统平台上都可以运行,那原理是什么？

我们所写的JAVA程序是".java"为后缀的源文件,但这些文件计算机无法直接执行，需要先进行编译环节,通过编译变为以".class"为后缀的字节码文件,这个字节码文件交由JVM(JAVA虚拟机)来运行.

那我们只要在需要运行java应用程序的OS(操作系统)上，安装一个JVM,由JVM来负责Java程序在该系统中的运行即可。不同的OS(操作系统)都有与之对应的JVM,所以只需要写一个Java程序,就可以在多个不同的操作系统上执行。这样就实现了Java程序的跨平台性。也称为Java具有良好的可移植性。

在这里插入图片描述
注意JVM是Java语言能够跨平台的前提,但是JVM本身不跨平台

1.2 HelloWorld 案例

记事本方式

1 新建一个java文件

  • 文件后缀名为.java
  • HelloWorld.java
    在这里插入图片描述
    2 记事本打开文件，编写代码
	public class HelloWorld{
		public static void main(String[] args){
			System.out.print("HelloWorld");
		}
	}

3 编译javac java文件名，生产一个class文件
在这里插入图片描述
注意：文件路径与文件名
4 运行class文件，java class文件名
在这里插入图片描述

IDEA创建HelloWorld

1 创建项目
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
2 创建类
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述

1.3 运行原理

我们编写的文件是以”.java”为后缀的源代码文件,Ctrl+S保存时会触发编译器idea对写好的代码进行编译,
编译后生成以”.class”为后缀的字节码文件,当Ctrl+F11运行代码时,JVM就会加载字节码文件, 并加载main方法执行程序, 进而在控制台显示代码效果
在这里插入图片描述

1.4 案例解析

/**
 *public --公共的，作为类的修饰符
 *class --类，用于定义类的一个特殊的单词
 *HelloWorld --类名，驼峰命名法，每个单词的首字母大写
 *{ } -- 类的主体内容
 *注意:{} () "" 都是成对出现的,而且都是英文符号
 */
public class HelloWorld {

    /**
     * public static void main(String[] args) {}--入口函数的标准写法
     * public --公共的，作为main()的修饰符
     * static --静态的
     * void --空，无，表示这个方法没有返回值
     * main --方法名
     * () --表示这是一个方法
     * String[] args--main()的固定写法
     * {} -- 方法的主体内容
     */
    public static void main(String[] args) {

        /**
         * System --系统，表示要发出一个系统指令
         * out -- 向外输出
         * println() --如何输出/输出的方式：输出后换行
         * print() --如何输出/输出的方式：输出后不换行
         * "Hello world!"--向控制台输出的具体内容
         * ;表示结束符
         */
        System.out.println("Hello World !");
    }
}

1.5 基础语法

标识符

标识符可以简单的理解成一个名字。
在Java中，我们需要给代码中的很多元素起名，包括类名、方法名、字段名、变量名等等。我们给对应元素起的名称就被称为标识符，一个正确的标识符需要遵循以下规则：

  1. 标识符可以由字母、数字、下划线（_）、美元符（$）组成，但不能包含 @、%、空格等其它特殊字符
  2. 不能以数字开头。如：123name 就是不合法
  3. 标识符严格区分大小写。如: tmooc 和 tMooc 是两个不同的标识符
  4. 标识符的命名最好能反映出其作用，做到见名知意。
  5. 标识符不能是Java的关键字

关键字

在Java中,有一些单词被赋予了特定的意义,一共有50个关键字。
这50个单词都是全小写,其中有两个保留字:const和goto。
注意,关键字不能被用作标识符！
在这里插入图片描述
需要注意的是，除了上述的50个关键字以外，true,false,null也不可以被用作标识符~

注释

几乎所有编程语言都允许程序员在代码中输入注释
因为编译器会忽略注释,所以注释并不会影响程序的运行结果。
注释的真正作用是： 它可以向任何阅读代码的人描述或者解释程序的实现思路,如何使用以及其它任何相关信息， 提高代码的可读性,方便后期的维护与复用。
Java的注释有3种:

  1. 单行注释: 注释单行内容.
    格式: 每行都以”//”开头.
    快捷方式: Ctrl+/ 添加注释,同样的快捷键,再按一次取消注释

  2. 多行注释：注释多行内容,虽然叫多行注释,也可注释单行内容.
    格式: 以” /* ”开头， 以” * / ”结束.
    快捷方式: 可以输入” /* ”之后按回车添加注释

  3. 文档注释: 一般用来注释类和方法,通过注释内容来记录类或者方法的信息.
    格式: 以” /** ”开头。 以” * / ”结尾
    快捷方式: 输入 “ /** ” 之后按回车添加注释

二、变量、数据类型和运算符

2.1 变量

在JAVA中，我们需要记录一些数据
但这些数据的值是不固定的，总在变，我们可以把这些数据理解为变量。
我们通过三个元素来描述变量：变量类型 变量名以及变量值。
定义变量的两种格式：
格式一：声明变量时并且赋值：int age = 18;
格式二：先声明变量：String tel ; 然后给变量赋值：tel = 119;

  1. 变量名必须是一个有效的标识符
  2. 变量名不可以使用java关键字
  3. 变量名不能重复

2.2 数据类型

基本类型介绍(八种)

变量要保存值，这个值是存在内存中的，所以就需要向内存申请存储空间
java是一个强类型的语言
为了方便内存管理系统根据变量类型更加合理的分配内存空间
会把我们常见的数据,分成不同类型
不同类型分配的内存大小是不同的，这个大小的单位就是字节Byte
在这里插入图片描述
拓展：常用的转换关系:
位 bit，来自英文bit，音译为“比特”，表示二进制位。
1 Byte = 8 Bits (1字节 = 8位)
1 KB = 1024 Bytes 1 MB = 1024 KB 1 GB = 1024 MB

练习：输出个人信息

需求: 在控制台打印: java讲师今年23岁，月薪3000，感慨java是世界上最好的语言

/**本类用于完成个人信息输出案例*/
public class Demo01 {
    //1.添加程序的入口函数main()
    public static void main(String[] args) {
        /**1.定义变量的规则：变量的类型  变量名  变量的值*/
        /**2.String是字符串类型，用来保存多个字符*/
        //2.定义变量
        String name = "哈哈"; //定义一个String变量用来保存姓名"哈哈"
        int age = 23; //定义一个age变量用来保存年龄23
        double salary = 3000.9;//定义一个变量salary用来保存工资
        //3.我们可以通过打印语句查看变量的值
        System.out.println(name);
        System.out.println("java讲师"+name+"，今年"+age+"岁，月薪"+salary+"，感慨Java是世界上最好的语言！");
    }
}

基本类型的类型转换

箭头开始的地方是小类型,箭头指向的地方是大类型
我们此处所指的"大"和"小",指的是对应类型的取值范围,不是字节数。
在这里插入图片描述
小到大(隐式转换)

byte m = 120;
int n = m;//小转大,右面的m是小类型,给左面的n大类型赋值,可以直接使用
float f = 3.2f; double d = f; -->可以执行

大到小(显式转换)

int x = 999;
byte y =(byte)x;//大转小,右面x给左面的y小类型赋值,不可以,需要强制类型转换
  1. 转换过程中可能导致溢出或损失精度 例如：int i =128; byte b = (byte)i; //打印的结果是-128 因为
    byte 类型是 8 位，最大值为127，所以当 int 强制转换为 byte 类型时，值 128 时候就会导致溢出。
  2. 浮点数到整数的转换是通过舍弃小数得到，而不是四舍五入
    例如：float f = 32.7f; int a2 =(int) f; //打印的结果是32
  3. 不能对boolean类型进行类型转换。

口诀
在这里插入图片描述

2.3 运算符

概述

运算符 用于连接 表达式 的 操作数，并对操作数执行运算。
例如，表达式num1+num2，其操作数是num1和num2，运算符是”+”。
在java语言中，运算符可分为5种类型：
算术运算符、赋值运算符、关系运算符、逻辑运算符、位运算符。
根据操作数的不同，运算符又分为单目运算符、双目运算符和三目运算符。
单目运算符只有一个操作数，双目运算符有两个操作数，三目运算符则有三个操作数。
位运算符涉及到二进制位的运算，在java 程序中运用不是很多。

运算符速查表

在这里插入图片描述

练习：求圆形的面积

需求:求出指定半径圆的面积
公式:圆的面积：π * r * r

import java.util.Scanner;

public class Demo02 {
    //1.创建程序的入口函数main()
    public static void main(String[] args) {
        /**等号右边的值赋值给等号左边的变量来保存*/
        //1.提示用户输入圆的半径：
        System.out.println("请您输入要求的半径值：");

        /**变量的第二种定义方式：先定义，再赋值*/
        //2.1定义一个变量用来保存圆的半径
        //double r = 5.5;
        double r ;
        //2.2接收用户在键盘上输入的数据，并把这个数据交给r保存
        //开启扫描(发出一个系统指令，准备接收控制台输入的数据)
        //nextDouble()控制用户只能输入double类型的数据，否则报错
        r = new Scanner(System.in).nextDouble();

        //根据半径值求出圆的面积
        double circleArea = 3.14 * r * r;
        //打印计算的结果
        System.out.println("圆的面积是："+circleArea);
    }
}

练习：测试自增自减

/**本类用于测试取余运算符*/
public class Demo03 {
    //0.创建程序的入口函数main
    public static void main(String[] args) {
        //1.测试除法与取余数
        System.out.println(25 / 10);//2
        System.out.println(25 % 10);//5

        //2.练习1：获取一个两位数59的十位与个位
        int x = 59;
        System.out.println(x/10);//打印十位,5
        System.out.println(x%10);//打印个位,9

        //3.练习2：获取一个三位数159的百位、十位与个位
        int y = 159;
        System.out.println(y / 100);//打印百位
        System.out.println(y / 10 % 10);//打印十位
        System.out.println(y % 10);//打印个位

        //4.测试自增自减运算符
        /** 前缀式：符号在前：++a --a ,先改变变量本身的值，再使用，比如打印
         * 后缀式：符号在后:   a++ a--，先使用，再改变变量本身的值
         * ++:相当于给变量本身的值+1
         * --: 相当于给变量本身的值-1*/
        System.out.println("我是一个无情的分界线");

        /**普通的四则运算并不会改变变量本身的值
         *    自增自减运算符才会改变变量本身的值*/
        int z = 1;
        System.out.println(z+4);//5
        System.out.println(z);//1

        int a = 1;
        System.out.println(++a);//2
        System.out.println(a);//2

        int b = 1;
        System.out.println(b++);//1
        System.out.println(b);//2

        int c = 1;
        System.out.println(--c);//0,符号在前，先自减，再打印
        System.out.println(c);//0，上面已经自减过了

        int d = 1;
        System.out.println(d--);//1，符号在后，先打印，再自减
        System.out.println(d);//0,打印过后，自减成0

        //之前的代码会对后面的代码产生影响，c的值是0
        System.out.println(c);//0
        System.out.println(--c-c-c--);//1,-1-(-1)-(-1)=1
        System.out.println(c);//-2,经历了两次自减，所以0-2=-2

    }
}

练习：测试逻辑运算符

/**本类用于测试逻辑运算符*/
public class Demo04 {
    public static void main(String[] args) {
        /**与：全真才真*/
        System.out.println("测试单与：");
        System.out.println(true & true);
        System.out.println(true & false);
        System.out.println(false & true);
        System.out.println(false & false);
        System.out.println("测试双与：");
        System.out.println(true && true);
        System.out.println(true && false);
        System.out.println(false && true);
        System.out.println(false && false);
        /**或：全假才假*/
        System.out.println("测试单或：");
        System.out.println(true | true);
        System.out.println(true | false);
        System.out.println(false | true);
        System.out.println(false | false);
        System.out.println("测试双或：");
        System.out.println(true || true);
        System.out.println(true || false);
        System.out.println(false || true);
        System.out.println(false || false);
    }
}

练习：求两数的最大值

需求:接收用户输入的两个整数,并比较输出这两个数的最大值

import java.util.Scanner;

public class Demo05 {
    public static void main(String[] args) {
        //1.提示用户输入
        System.out.println("请输入您要比较的第一个整数:");
        //2.接收用户输入的整数,并把这个值交给变量a来保存
        int a = new Scanner(System.in).nextInt();
        System.out.println("请输入您要比较的第二个整数:");
        int b = new Scanner(System.in).nextInt();

        //3.比较接收两个数,使用三元运算符
        /**1 ? 2 : 3
         * 1是表达式,若1的结果为true,结果取2位置,若1的结果为false,结果取3位置
         * */
        //4.定义变量max来保存比较的最大值
        int max = a > b ? a : b;

        //5.打印最大值
        System.out.println("两个数的最大值是:"+max);
        /**思考题:如何判断3个数的最大值? int max = a>b?(a>c?a:c):(b>c?b:c);*/
    }
}

总结1: 算术运算符之自增自减运算符

a是操作数，++是自增运算符，- -是自减运算符，自增和自减运算符即可以放在变量的前面，也可以放在变量的后面，例如：a++、++a、a- -、- -a等。
自增（++）：将变量的值加1
分前缀式（如++a）和后缀式（如a++）。前缀式是先加1再使用；后缀式是先使用再加1。
自减（- -）：将变量的值减1
分前缀式（如- -a）和后缀式（如a- -）。前缀式是先减1再使用；后缀式是先使用再减1。

总结2: 逻辑运算符

逻辑运算符连接两个关系表达式或布尔变量，用于解决多个关系表达式的组合判断问题
注意逻辑运算符返回的运算结果为布尔类型
通常，我们用0表示false，用1表示true
与：表示并且的关系
&单与： 1 & 2 ，结果想要是true，要求1和2都必须是true
&&双与(短路与)：1 && 2 ，当1是false时，2会被短路，提高程序的效率
或：表示或者的关系
|单或： 1 | 2，结果想要是true，要求1和2只要有一个为true就可以
||双或(短路或)：1 || 2，当1是true时，2会被短路，提高程序效率

总结3: 优先级控制

当一个表达式包含多个运算符时，就需要考虑运算符的优先级，优先级高的运算符先参与运算，优先级低的运算符后参与运算。在实际的开发中，不需要特别去记忆运算符的优先级别，也不要刻意的使用运算符的优先级别，对于不清楚优先级的地方使用小括号辅助进行优先级管理。

三、选择结构（if else）

在这里插入图片描述

练习：求平年闰年

需求:接收用户输入的年份,判断是平年还是闰年
如果年份是闰年,需要满足下面两个条件之一:
条件1:能被4整除,并且不能被100整除
条件2:能被400整除

import java.util.Scanner;

public class demo06 {
    public static void main(String[] args) {
        //1.提示并接收用户输入的年份
        System.out.println("请输入您要判断的年份:");
        int year = new Scanner(System.in).nextInt();

        //2.定义一个变量用来保存结果
        String result = "平年";//默认值是平年,假设每年都是平年

        //3.判断用户输入的年份是否满足闰年的条件
        /**解决方案1*/
        /**条件1:能被4整除,并且不能被100整除*/
//		if(year % 4 == 0) {//能被4整除
//			if(year %100 != 0) {//不能被100整除
//				result = "闰年";//符合闰年的条件1,修改结果为闰年
//			}
//		}
//		/**条件2:能被400整除*/
//		if(year % 400 == 0) {//能被400整除
//			result = "闰年";//符合闰年的条件2,修改结果为闰年
//		}
        /**解决方案2*/
        /**判断结构 if(判断条件){满足判断条件以后执行的代码} */
        //if(条件1  || 条件2){是闰年 }
        //if((小条件1  && 小条件2) || 条件2){ 是闰年 }
        //if((能被4整除  && 不能被100整除) || 能被400整除){ 是闰年 }
        if((year % 4 == 0 && year %100 != 0) || year % 400 == 0){
            result = "闰年";//符合闰年的条件,修改结果为闰年
        }
        System.out.println(year+"年是"+result);
    }
}

练习：商品打折案例

需求: 接收用户输入的原价。满1000打9折;满2000打8折;满5000打5折

import java.util.Scanner;

public class Demo07 {
    public static void main(String[] args) {
        //1.提示用户输入原价
        System.out.println("请输入商品原价:");
        //2.接收用户输入的原价
        double price = new Scanner(System.in).nextDouble();
        //3.计算打折后的价格
        //3.1定义变量用来保存打折后的价格
        double count = price;//初始值是商品的原价
        //3.2判断用户的打折段位并打折
        if(price >= 5000) {//满5000
            count = price *0.5;//打5折
        }else if(price >= 2000) {//满2000
            count = price * 0.8;//打折8折
        }else if(price >= 1000) {//满1000
            count = price *0.9;//打9折
        }
//		if(1000 <= price && price< 2000) {
//			count = price *0.9;
//		}else if(2000 <= price && price < 5000) {
//			count = price * 0.8;
//		}else if(price >= 5000) {
//			count = price *0.5;
//		}
        //3.3输出用户实际支付的价格
        System.out.println("您实际应该支付:"+count);
    }
}

练习: 统计学员得分段位案例

需求：接收用户输入的成绩。成绩 90分及以上 优秀 ；80-89 良好 ； 70-79 中等 ； 60-69 及格 ；60分及以下 不及格

import java.util.Scanner;

public class Demo08 {
    public static void main(String[] args) {
        //1.提示并接收学员的分数
        System.out.println("请输入你的分数：");
        int score = new Scanner(System.in).nextInt();

        /**为了增强程序的健壮性，如果用户输入的数据不符合规则，就结束*/
        if(score <0 || score >100 ) {
            System.out.println("输入数据不合法，请重新输入！！！");
        }else {
            //2.判断分数的段位，并输出结果
            if(score >= 90) {//大于90
                System.out.println("优秀！");
                //}else if(score>=80 && score <=89) {
            }else if(score>=80) {//[80,90)
                System.out.println("良好！");
            }else if(score>=70) {//[70,80)
                System.out.println("中等！");
            }else if(score>=60) {//[60,70)
                System.out.println("及格！");
            }else {//小于60
                System.out.println("不及格！");
            }
        }
    }
}

四、选择结构（switch case）

switch case 语句用来判断一个变量与一系列值中某个值是否相等，每个值称为一个分支。
当一个case成立，从这个case向后穿透所有case，包括default，直到程序结束或者遇到break程序才结束
在这里插入图片描述

练习：数字匹配

/*本类用于练习switch结构*/
/**总结：
 * 1.变量a的类型byte short char int String
 * 2.会拿着变量a的值依次与case后的值做比较，如果不加break,
 *        会向后穿透所有case,包括default
 * 3.如果设置了default“保底选项”，并且没有任何case匹配到的话，就执行default
 * 4.break与default是可选项，根据具体业务来决定加不加
 * */
public class Demo09 {
    //1.创建程序的入口函数main
    public static void main(String[] args) {
        //2.定义一个变量
        int a = 19;
        //3.完成switch结构的测试
        switch(a) {
            case 1 : System.out.println(1);break;
            case 2 : System.out.println(2);break;
            case 3 : System.out.println(3);break;
            case 4 : System.out.println(4);break;
            case 5 : System.out.println(5);break;
            default : System.out.println(0);
        }
    }
}

练习: Switch中的String类型

public class Demo10 {
    public static void main(String[] args) {
        String day = "星期五";
        switch(day) {
            case "星期一" : System.out.println("星期一吃四川火锅");break;
            case "星期二" : System.out.println("星期二吃齐齐哈尔烤肉");break;
            case "星期三" : System.out.println("星期三吃新疆羊肉串");break;
            case "星期四" : System.out.println("星期四吃阳澄湖大闸蟹");break;
            case "星期五" : System.out.println("星期五吃兰州拉面");break;
            case "星期六" : System.out.println("星期六吃南昌拌粉");break;
            case "星期日" : System.out.println("星期日吃武汉藕汤");break;
            default : System.out.println("想吃点啥吃点啥吧~");
        }
    }
}

switch结构的注意事项

  1. switch 语句中的变量类型可以是： byte、short、int 、char、String(jdk1.7以后支持)
  2. switch 语句可以拥有多个 case 语句
  3. 每个 case 后面跟一个要比较的值和冒号,且此值的数据类型必须与变量的数据类型一致
  4. 当变量值与 case 语句值相等时，开始执行此case
    语句的内容,执行完会判断此行代码是否有break,如果有,结束执行,如果没有,会继续向后执行穿透所有case,包括default
  5. switch 语句可以包含一个 default 分支，该分支一般是写在switch 语句的最后
  6. 如果在default之前的case有break,则default不会执行

五、循环结构（一）

循环结构是指在程序中需要反复执行某个功能而设置的一种程序结构。
它由循环体中的条件，判断继续执行某个功能还是退出循环。
根据判断条件,循环结构又可细分为先判断后执行的循环结构和先执行后判断的循环结构。

5.1 循环结构while

形式(先判断,再执行)
在这里插入图片描述

练习：猜数字之while练习

package cn.huo.xh;

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

public class Demo01_WhileTest {
    public static void main(String[] args) {

        //让程序产生一个随机数
        //java.util.Random,注意导包,快捷键:Ctrl+Shift+O
        int r = new Random().nextInt(100);//参数100是自定义的,此时生成的随机数范围是[0,100)的整数

        System.out.println("打个小抄:"+r);

        //1.写一个死循环
        while(true) {//死循环--需要设置程序的出口
            //2.接收用户输入的值
            System.out.println("猜猜看~");
            int input = new Scanner(System.in).nextInt();
            //3.判断是否猜对(拿用户猜的数字与生成的随机数做比较)
            if(input > r) {
                System.out.println("猜大了,继续猜猜看");
            }else if(input < r) {
                System.out.println("猜小了,继续努力");
            }else if(input == r) {
                System.out.println("猜对了!");
                //一定注意:要设置程序出口!!!
                break;
            }
        }
    }
}

5.2 循环结构 do-while

形式(先执行,再判断,循环体代码保证最少执行一次)
在这里插入图片描述

do-while练习

需求：在0-300的范围中生成一个随机数，打印每次生成的随机数，直到生成的随机数小于50，程序结束

import java.util.Random;

public class Demo01_DoWhileTest {
    public static void main(String[] args) {
        int n;
        do {
            System.out.println("我是循环体");
            n = new Random().nextInt(300);//生成随机数的范围[0,300)
            System.out.println(n);
        }while(n>50);//循环条件  随机数n大于50 则继续生成随机数；直到随机数小于50结束循环
    }
}

需求：如果用户输入错误，可以重复输入直到输入正确，执行相应的操作后退出循环
在这里插入图片描述

import java.util.Scanner;

public class Demo03_DoWhileTest2 {
    public static void main(String[] args) {
        System.out.println("欢迎使用MyShopping管理系统\n");
        System.out.println("*******************************");
        System.out.println("\t1.客 户 信 息 管 理");
        System.out.println("\t2.购 物 结 算");
        System.out.println("\t3.真 情 回 馈");
        System.out.println("\t4.注 销");
        System.out.println("*******************************\n");
        int choice;		//用户选择
        boolean isRight;	//输入是否正确
        System.out.print("请选择，输入数字：");
        Scanner input = new Scanner(System.in);
        do{
            isRight = true;
            choice = input.nextInt();
            if(choice == 1){
                System.out.println("执行客户信息管理");
            }else if(choice == 2){
                System.out.println("执行购物结算");
            }else if(choice == 3){
                System.out.println("执行真情回馈");
            }else if(choice == 4){
                System.out.println("执行注销");
            }else{
                System.out.print("输入错误，请重新输入数字：");
                isRight = false;
            }
        }while(!isRight);
        System.out.println("\n程序结束");
    }
}

六、循环结构（二）

6.1 for循环

在这里插入图片描述

练习：打印100次slogon/打印0到10/打印10到0/打印8,88,888,8888

public class Demo04_ForTest1 {
    public static void main(String[] args) {
        //需求:打印100次自己的宣言
        //for(开始条件;循环条件;更改条件){循环体;}
        for(int i = 1;i<=100;i++) {
            System.out.println("又不是没那条件，干就完啦！");
        }
        //需求:打印0到10
        //for(开始条件;循环条件;更改条件){循环体;}
        //0 1 2 3 4 5 6 7 8 9 10
        //从哪开始：0
        //到哪结束：10
        //怎么变化：+1 ++
        for(int i = 0;i<=10;i++) {
            System.out.println(i);
        }
        System.out.println("**********************");
        //需求:打印10到0
        //10 9 8 7 6 5 4 3 2 1 0
        //从哪开始：10
        //到哪结束：0
        //怎么变化：-1  --
        //for(开始条件;循环条件;更改条件){循环体}
        for(int i = 10 ;i >= 0;i--) {
            System.out.println(i);
        }
        //需求：打印8，88，888，8888,
        //8 88 888 8888
        //从何开始：8
        //到哪结束：8888
        //如何变化：*10+8
        for(int i =8 ; i <= 8888 ; i=i*10+8) {
            System.out.print(i+",");//使用的是print(),打印后不换行
        }
    }
}

练习:求[1,100]以内元素之和,偶数之和。

public class Demo05_ForTest2 {
    public static void main(String[] args) {
        /*需求：求出1-100以内所有偶数的和*/
        //1.定义变量用来保存最终求和的结果
        int sum = 0;
        //2.创建循环，依次循环1-100范围内的数
        for(int i = 1;i <101;i++) {
            //3.过滤出来需要累加的偶数
            if(i%2 == 0) {
                //if(i%2 == 1) {//过滤奇数
                //4.能进来，说明是偶数，累加
                sum = sum +i;
            }
        }
        //5.在for循环结束以后，打印所有偶数累加的和
        System.out.println(sum);
        

        /*需求：求出1-100以内所有数的和*/
        /*
        //1.定义一个变量用来保存求和的结果
        int sum = 0;
        //2.创建循环，依次循环1-100范围内的数
        for(int i = 1;i<=100;i++) {
            //3.将本轮循环到的数字累加到最终的结果中
            sum = sum + i;
        }
        //4.打印最终累加的结果
        System.out.println(sum);
        */
    }
}

6.2 break与continue

break: 直接结束当前循环,跳出循环体,简单粗暴

  • break以后的循环体中的语句不会继续执行,循环体外的会执行
  • 注意如果是嵌套for循环,在内层循环遇到了break,只会跳出当前这一层内循环

continue: 跳出本轮循环,继续下一轮循环

  • continue后本轮循环体中的语句不会继续执行,但是会继续执行下轮循环,循环体外的也会执行

在这里插入图片描述

练习：测试Break与Continue

需求：找数字88
提示并接受用户输入100次数字，如果不是88，则继续输入，找到88就结束

import java.util.Scanner;

public class Demo06_BreakTest {
    public static void main(String[] args) {
        //循环体可以帮助我们执行重复的事情,控制for循环执行100次
        for(int i = 1;i <= 100; i++) {
            //在每一次循环中都要提示并接收用户输入的数字
            System.out.println("请输入数字:");
            int input = new Scanner(System.in).nextInt();
            if(input != 88) {//用户输入的不是88
                continue;//直接继续输入
                /**注意,不管是不是加continue,都可以在猜不对的情况下继续输入
                 * 只不过加了continue后效率更高,只要数据不等于88,就无需执行后面的代码
                 * 直接进行下一轮的猜数字即可* */
                /**break或者continue之后都不允许写代码,都是不可到达的代码*/
                //System.out.println(0);//Unreachable code
            }
            System.out.println("用来测试continue有没有跳过循环后半部分代码");
            if(input == 88) {//找到88了
                System.out.println("恭喜您,猜对了!");
                break;//结束程序
            }
        }
    }
}

6.3 三种循环的区别

  • for：知道循环次数
  • while/do while：当循环次数不确定时
  • while：先判断，不符合规则，不执行代码
  • do while：代码最少被执行一次，再去判断，符合规则，再次执行代码
  • 循环之间都可以互相替代,但是一般最好选择合适的循环结构来完成代码

七、指导学习:循环使用

–练习1–

需求：用户进入游戏平台后，可以选择喜爱的游戏
使用switch选择结构
在这里插入图片描述

–练习2–

在这里插入图片描述

–练习3–

在这里插入图片描述

–练习4–

在这里插入图片描述

–练习5–

需求： 为了维护用户信息，需要将其信息录入系统中

  • 用户的信息包括：用户编号、年龄、积分
  • 要求年龄10岁以上
    在这里插入图片描述

八、数组（重点）

8.1 概念

数组Array，标志是[ ] ,用于储存多个相同类型数据的集合
想要获取数组中的元素值，可以通过脚标（下标）来获取
数组下标是从0开始的,下标的最大值是数组的长度减1
在这里插入图片描述

8.2 创建数组

  1. 动态初始化
    int[] a = new int[5];
  2. 静态初始化
    int[] b = new int[]{1,2,3,4,5};
    int[] c = {1,2,3,4,5};

8.3 创建数组过程分析

  • 程序创建数组 int[] a = new int[5]; 时发生了什么?
  • 在内存中开辟连续的空间,用来存放数据,长度是5
  • 给数组完成初始化过程,给每个元素赋予默认值,int类型默认值是0
  • 数组完成初始化会分配一个唯一的地址值
  • 把唯一的地址值交给引用类型的变量a去保存

数组名是个引用类型的变量,它保存着的是数组的地址,不是数组中的数据

8.4 数组的长度

数组的长度用 length属性来表示,数组一旦创建，长度不可改变
数组的长度允许为0

8.5 练习：向数组中存入数据hello

在这里插入图片描述

import java.util.Arrays;

public class Demo01 {
    public static void main(String[] args) {
        //1.创建数组
        //1.1静态创建--创建的时候已经知道了每一个元素的值
        char[] c1 = {'h','e','l','l','o'};
        char[] c2 = new char[] {'h','e','l','l','o'};

        //1.2动态创建--知道了数组的长度，后面再具体赋值
        char[] c3 = new char[5];//在内存中开辟一块连续的内存空间，用来存放5个字符
        //1.2.2给c3数组动态的赋值
        /**我们通过数组的下标来操作数组中的每一个元素，注意数组下标从0开始*/
        c3[0] = 'h';//给数组中的第1个元素赋值
        c3[1] = 'e';//给数组中的第2个元素赋值
        c3[2] = 'l';//给数组中的第3个元素赋值
        c3[3] = 'l';//给数组中的第4个元素赋值
        c3[4] = 'o';//给数组中的第5个元素赋值

        //2.打印查看刚刚创建好的数组
        System.out.println(c1);
        System.out.println(c2);
        System.out.println(c3);

        //3.创建String类型的数组，存放数据"a","b","c"
        String[] s1 = {"a","b","c"};
        String[] s2 = new String[] {"a","b","c"};
        String[] s3 = new String[3];
        s3[0] = "a";//给s3数组的第1个元素赋值为"a"
        s3[1] = "b";//给s3数组的第2个元素赋值为"b"
        s3[2] = "c";//给s3数组的第3个元素赋值为"c"

        /**char类型的数组底层中做了处理，可以直接打印数组中的具体元素
         * 除了char类型以外的数组想要查看数组中的具体元素，需要使用数组的工具类Arrays
         * 具体方式：Arrays.toString(数组名);
         * 注意Arrays使用时需要导包*/
        //4.打印创建好的数组
        System.out.println(s1);//打印出来的是数组的地址值
        System.out.println(Arrays.toString(s2));

        //5.查看数组的长度--数组中存放的元素的个数
        /**数组一旦创建，长度不可改变，如果想要增加/删除数组中的元素
         * 只能先创建一个新长度的数组，再将原来的数据复制过去*/
        System.out.println(c1.length);
        System.out.println(s1.length);
    }
}

8.6 数组的遍历

遍历:从头到尾,依次访问数组每一个位置,获取每一个位置的元素.形式如下:
我们通过数组的下标操作数组,所以for循环变量操作的也是数组下标

开始:开始下标0 结束:结束下标length-1 如何变化:++
for(从下标为0的位置开始 ; 下标的取值 <= 数组的长度-1 ; 下标++){
循环体;
}

8.7 练习(月天数；存1-10；随机数组)

练习1：输出每个月的天数

package cn.huo.test08;

public class Demo02 {
    public static void main(String[] args) {
        //1.创建数组用来存12个月的天数
        int[] a = {31,28,31,30,31,30,30,31,30,31,30,31};

        //2.输出每个月的天数打印到控制台
        //数组的遍历--通过循环的方式--操作的是数组的下标
        //循环开始:a[0]--数组中的第一个元素
        //循环结束:a[a.length-1]--数组中的最后一个元素
        //如何变化:++
        //for(int i = 0 ; i <=a.length-1 ; i++) {
        for(int i = 0 ; i <a.length ; i++) {
            //a[i]--根据下标i来获取数组a中对应位置上元素的值
            System.out.println((i+1)+"月有:"+a[i]+"天");
        }
    }
}

练习2：遍历数组，存入1到10

import java.util.Arrays;

public class Demo03 {
    public static void main(String[] args) {
        //1.创建数组--动态创建
        int[] a = new int[10];

        //2.遍历数组,依次给每个位置赋值
        //循环开始:a[0]--数组中的第一个元素
        //循环结束:a[a.length-1]--数组中的最后一个元素
        //如何变化:++
        for(int i = 0 ; i <= a.length-1 ; i++) {
            //a[i]--根据下标i来获取数组a中对应位置上元素的值
            a[i] = i+1;
        }//for循环结束
        //3.在存入10个数据之后,打印a数组
        System.out.println(a);//[I@15db9742
        //除了char类型的数组,其他类型的数组想要查看具体内容需要借助工具类Arrays
        //Arrays.toString(要打印的数组的名字)来查看数组中的具体内容
        System.out.println(Arrays.toString(a));//[1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
    }
}

练习3：创建随机数组

import java.util.Arrays;
import java.util.Random;

public class Demo04 {
    public static void main(String[] args) {
        //1.创建数组--动态
        int[] a = new int[10];
        //2.遍历数组,给数组中的每个元素赋值
        for(int i = 0 ; i <a.length ; i++) {
            //100是自定义的数据,表示生成的随机整数的范围是[0,100)
            a[i] = new Random().nextInt(100);
            //a[i] = new Random().nextInt(100)+1;//取值范围前后都+1-->[1,101)
        }
        //3.使用数组的工具类查看数组中的元素
        System.out.println(Arrays.toString(a));
    }
}

8.8 数组工具类Arrays

Arrays.toString(数组)

  • 把数组里的数据,用逗号连接成一个字符串[值1,值2]

Arrays.sort(数组)

  • 对数组进行排序,对于基本类型的数组使用的是优化后的快速排序算法,效率高
  • 对引用类型数组,使用的是优化后的合并排序算法
package cn.huo.test08;

import java.util.Arrays;

public class Demo05 {
    public static void main(String[] args) {
        //1.创建无序数组
        int[] a = {21,96,75,23,25};

        //底层使用的排序算法是进行优化后的快速排序算法
        Arrays.sort(a);//对无序数组进行直接排序
        System.out.println(Arrays.toString(a));
    }
}

Arrays.copyOf(数组，新的长度)

  • 把数组赋值成一个指定长度的新数组
  • 新数组的长度 大于 原数组, 相当于复制,并增加位置
  • 新数组的长度 小于 原数组, 相当于截取一部分数据
import java.util.Arrays;

public class Demo06 {
    public static void main(String[] args) {
        //1.创建数组
        int[] from = {1,2,3,4,5};//数组一旦创建，长度不可改变

        //2.1 数组的普通复制
        /**copyOf()用于完成数组的复制，两个参数：
         * 参数1：要复制哪个数组
         * 参数2：新数组的长度*/
        int[] to = Arrays.copyOf(from, 5);
        System.out.println(Arrays.toString(to));

        //2.2数组的扩容
        /**扩容：给数组扩大容量，新数组的长度>原数组的长度
         * 扩容思路：先创建对应长度的新数组，每个位置上都是默认值0
         * 然后从原数组中将元素复制到新数组，没有被覆盖的元素还是默认值0*/
        int[] to2 = Arrays.copyOf(from, 10);
        System.out.println(Arrays.toString(to2));

        //2.3数组的缩容
        /**缩容：缩小数组的容量，新数组的长度<原数组的长度
         * 缩容思路：先创建对应长度的新数组，每个位置上都是默认值0
         * 然后从原数组中复制指定个数的元素到新数组中，类似于截取*/
        int[] to3 = Arrays.copyOf(from, 3);
        System.out.println(Arrays.toString(to3));

        //2.4指定首尾截取原数组中的元素
        /**copyOfRange()用于完成数组的截取，3个参数：
         * 参数1：要截取哪个数组【原数组】
         * 参数2：从原数组的哪个下标开始
         * 参数3：到原数组的哪个下标结束
         * 注意：截取的元素包含开始下标处的元素，不包含结束下标处的元素*/
        int[] to4 = Arrays.copyOfRange(from, 2, 4);
        System.out.println(Arrays.toString(to4));
    }
}

8.9 数组插入数据

有一组学员的成绩{99，85，82，63， 60}，将它们按升序排列。要增加一个学员的成绩，将它插入成绩序列，并保持升序

  • 将成绩序列保存在长度为6的数组中
  • 将该位置后的元素后移一个位置
  • 将增加的学员成绩插入到该位置

在这里插入图片描述

import java.util.Arrays;
import java.util.Scanner;

public class Demo07 {
    public static void main(String[] args) {
        //1.创建数组
        int[] from = {99,85,82,63,60};//数组一旦创建，长度不可改变

        //2 数组的扩容
        int[] to = Arrays.copyOf(from, from.length + 1);

        //3 输入新增成绩
        System.out.println("请输入新增成绩：");
        int cj=new Scanner(System.in).nextInt();

        //4 比较成绩找到要插入的位置
        int index=0; //存放要插入的下标
        for(int i=0;i<from.length;i++){
            if(from[i]<cj){
                index=i;
                break;
            }
        }
        System.out.println("插入成绩的下标是："+index);

        //5 依次移动插入位置后面的元素
        for(int i=to.length-1;i>index;i--){
            to[i]=to[i-1];
        }
        //6 插入数据
        to[index]=cj;
        System.out.println(Arrays.toString(to));
    }
}

–练习–

练习1：字符逆序输出

在这里插入图片描述
练习2：求最低价格
需求：定义数组存储价格，并利用循环输入。求出最低价格
在这里插入图片描述
练习3：向有序序列中插入字符
需求：一组有序的字符序列a、b、c、e、f、p、u、z，向次字符序列中插入一个新的字符，要求插入之后字符序列仍保持有序
在这里插入图片描述

九、循环结构进阶

9.1 二重循环（嵌套for循环）

存在至少2层for循环,根据外层的条件，判断里层能否执行
如果能执行，就把里层代码都循环完毕后，再继续判断是否执行外层循环的下一次循环
在这里插入图片描述

9.2 嵌套for循环案例一

public class Demo01 {
    public static void main(String[] args) {
        //执行顺序
        //执行外层循环第一轮，i=1,打印1，遇到内层循环，打印12345,i自增成2
        //执行外层循环第二轮，i=2,打印2，遇到内层循环，打印12345,i自增成3
        //执行外层循环第三轮，i=3,打印3，遇到内层循环，打印12345,i自增成4
        //i为4，不满足循环条件，循环结束
        /**总结：外层循环执行一次(控制轮数)
         * 内层循环执行多次(在每一轮中执行的次数)*/
        for(int i = 1; i<=3;i++) {//外层循环
            System.out.println("外层循环的第："+i+"轮");
            for(int j = 1; j <=5 ; j++) {//内层循环
                System.out.println("内层循环的第"+j+"次");
            }
        }
        System.out.println("**************打印矩形******************");
        //执行顺序分析：
        //外层第一轮i=1,遇到内层循环,打印*****,内层循环结束，换行，i自增成2
        //外层第二轮i=2,遇到内层循环,打印*****,内层循环结束，换行，i自增成3
        //外层第三轮i=3,遇到内层循环,打印*****,内层循环结束，换行，i自增成4
        //此时i的值为4，不符合循环条件，循环结束
        /**总结：外层循环控制的是行数
         * 内层循环控制的是每行打印的列数*/
        for(int i = 1;i<=3;i++) {
            for(int j = 1;j<=5;j++) {
                System.out.print("*");
            }
            System.out.println();//用空白行来换行
        }
    }
}

9.3嵌套for循环案例二

在这里插入图片描述

import java.util.Scanner;

public class Demo02 {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        for(int i=1;i<=3;i++){
            int score=0;
            System.out.println("请输入第"+i+"个班级的成绩");
            for (int j=1;j<=4;j++){
                System.out.print("第"+j+"个学员的成绩:");
                score += sc.nextInt();
            }
            double avg=score/4.0;
            System.out.println("第"+i+"个班级参赛学员的平均分是:"+avg+"\n");
        }
    }
}

–练习–

练习一

在这里插入图片描述

练习二

在这里插入图片描述

练习三

在这里插入图片描述

练习四

在这里插入图片描述

9.4 二重循环使用continue

需求：在嵌套for循环案例二的基础上，统计成绩大于等于85分学员数；使用continue；
在这里插入图片描述

public class Demo02 {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        int num=0;
        for(int i=1;i<=3;i++){
            int score=0;
            int sum=0;
            System.out.println("请输入第"+i+"个班级的成绩");
            for (int j=1;j<=4;j++){
                System.out.print("第"+j+"个学员的成绩:");
                score = sc.nextInt();
                sum+=score;
                if(score<85){
                    continue;
                }
                num++;
            }
            double avg=sum/4.0;
            System.out.println("第"+i+"个班级参赛学员的平均分是:"+avg+"\n");
        }
        System.out.println("成绩85分以上的学员人数有"+num+"个");
    }
}

9.4 二重循环使用break

需求：使用break控制内层循环
在这里插入图片描述

public class Demo05 {
    public static void main(String[] args) {
        for (int i=1; i<=5;i++){
            for (int j=1;j<=5;j++){
                if(j>i){
                    break;
                }
                System.out.print("*");
            }
            System.out.println();
        }
    }
}

十、复习、幸运抽奖

阶段1：实现菜单的输出显示

需求：

  • 输出菜单
  • 选择菜单编号，输出菜单信息
  • 如果编号选择错误，输出“您的输入有误！”
  • 在这里插入图片描述

阶段2：实现循环执行功能

需求：

  • 系统询问用户是否继续
  • 如果用户选择继续，则可以继续选择菜单，否则程序结束，退出系统
  • 在这里插入图片描述

阶段3：实现注册

需求：

  • 输入用户名和密码，系统产生4位随机数作为卡号。
  • 注册成功，显示注册信息并修改注册标识为true
  • 在这里插入图片描述
    提示：
    int vip=new Random().nextInt(9999-1000)+1000; //会员卡号

阶段4：实现登录功能

  • 输入注册时的用户名和密码，登录成功，提示欢迎信息
  • 如果用户名和密码输入错误，提示用户继续输入，最多有3次输入机会
  • 在这里插入图片描述

阶段5：实现幸运抽奖

  • 登录成功后，用户选择幸运抽奖菜单，进入幸运抽奖功能
  • 输入会员卡号，系统生成5个4位随机数作为幸运数字
  • 如果会员卡号是其中之一，则成为本日幸运会员；否则不是幸运会员
  • 在这里插入图片描述

补充、局部变量，成员变量，方法

1 变量

1.1 概念

可以改变的数，称为变量。在Java语言中，所有的变量在使用前必须声明。
一般通过“变量类型 变量名 = 变量值 ;”这三部分来描述一个变量。如:int a = 3 ;
变量的使用原则：就近原则,即尽量控制变量的使用范围到最小

1.2 局部变量

位置:定义在方法里或者方法的声明上
注意:必须手动初始化来分配内存.如:int i = 5;或者int i; i = 5;
生命周期:随着方法的调用而存在,方法运行完毕就释放了

1.3 成员变量

位置:定义在类里方法外
注意:不用初始化,也会自动被初始化成默认值
生命周期:整个类中,类消失了,成员变量才会释放

变量的默认值测试

package cn.oop.test;

public class TestVariable {
    static String name;
    static byte b;//整数类型默认值都是0
    static short c;
    static int d;
    static long e;
    static float f;//小数类型的默认值是0.0
    static double g;
    static char j;//char类型的默认值是\u0000
    static boolean h;//boolean类型的默认值是false

    public static void main(String[] args) {
        System.out.println(name);//null,引用类型的默认值
        System.out.println(b);
        System.out.println(c);
        System.out.println(d);
        System.out.println(e);
        System.out.println(f);
        System.out.println(g);
        System.out.println(h);
        System.out.println(j);
        System.out.println(h);
    }
}

局部变量与成员变量测试

package cn.oop.test;

public class TestVariable2 {
    //2.定义成员变量:
    //1)位置:类里方法外
    //2)无需手动初始化,会自动赋予对应类型的默认值
    //3)作用域:在整个类中生效,类消失,变量才会消失
    static int count;

    //3.变量有一个使用的原则:就近原则
    static int sum = 200;
    public static void main(String[] args) {
        //1.定义局部变量:
        //1)位置:在方法里/局部代码块里
        //2)必须手动初始化
        //3)作用域:在方法/局部代码块中,对应的代码执行完局部变量就被释放
        int sum = 100;//定义在方法中的局部变量sum
        System.out.println(sum);//变量的就近原则:使用的都是自己附近的变量,100
        System.out.println(count);

        for (int i = 0; i < 10; i++) {//局部变量i只能在循环中使用
            System.out.println(i);
        }
        //System.out.println(i);//报错:无法引用变量i:i cannot be resolved to a variable
    }
}

1.4 成员变量与局部变量的区别

在这里插入图片描述

2 方法

2.1 概述

被命名的代码块,方法可以含参数可以不含参数,可以提高代码的复用性。

2.2 方法定义的格式

在这里插入图片描述

2.3 测试方法的调用顺序/参数/返回值

package cn.oop.test;

public class TestMethod {
    public static void main(String[] args) {
        System.out.println(1);
        /**2.通过方法名+参数列表的方式来调用方法的功能*/
        method1();//调用method1()
        System.out.println(2);
        method2(3);//调用method2()
        int add = method3(1,2);//调用method3()
        System.out.println(add);
    }

    /**3.如果方法想要返回值,必须修改返回值类型
     * 并且return对应类型的结果
     * 如果方法的返回值类型是void,不允许有返回值
     * */
    public static int method3(int i, int j) {
        /**4.通过return关键字将方法结果返回到调用位置*/
        return i+j;
    }

    public static void method2(int a) {
        System.out.println("我是method2："+a);
    }

    /**1.方法的修饰符 方法的返回值类型 方法名(方法参数){方法体}*/
    public static void method1() {
        System.out.println("我是method1");
    }
}

2.4 方法的重载

方法的重载是指在一个类中定义多个同名的方法,但是每个方法的参数列表不同(也就是指参数的个数和类型不同),程序在调用方法时,可以通过传递给他们的不同个数和类型的参数来决定具体调用哪个方法.

2.5 测试方法的重载

package cn.oop.test;

public class TestMethodOverload {
    public static void main(String[] args) {
        /**1.我们根据方法名+参数列表确定具体调用哪个方法*/
        /**2.方法的重载:
         * 在同一个类中,存在方法名相同,但参数列表不同的方法
         * 如果在同类中,同名方法的参数个数不同,一定构成重载
         * 如果在同类中,同名方法的参数个数相同,
         * 需要查看对应位置上参数的类型,而不是参数名,与参数名无关
         * (int a,String b)与(int b,String a)--不构成重载
         * (int a,String b)与(String a,int b)--构成重载
         * */
        //2.调用method()
        method();
        //4.调用method(int)
        method(666);
        //6.调用method(int,String)
        method(888,"哈哈");
    }

    //1.创建一个无参的method()
    public static void method() {
        System.out.println("哈哈哈哈我没参数");
    }
    //3.创建一个method(int n)
    public static void method(int n) {
        System.out.println("哈哈哈哈我的参数是:"+n);
    }
    //5.创建一个method(int n,String s)
    public static void method(int a,String b) {
        System.out.println(b+"今晚要干他"+a+"碗大米饭");
    }
    public static void method(String a,int b) {
        System.out.println(b+"今晚要干他"+a+"碗大米饭");
    }
}

十一、面向对象、类和对象

11.1 面向对象

概念

面向过程是一种编程思想，它强调的是过程，意思是我们做任何事，都需要亲力亲为。
面向对象也是一种编程思想，相对于面向过程，我们的身份可以由原来问题的执行者变为指挥者，进而把生活中很多复杂的问题变得简单化。

面向对象的三大特征

  1. 封装: 把相关的数据封装成一个“类”组件
  2. 继承: 是子类自动共享父类属性和方法，这是类之间的一种关系
  3. 多态: 增强软件的灵活性和重用性

11.2 类和对象

类

  1. Java语言最基本单位就是类，相当于类型。
  2. 类是一类事物抽取共同属性与功能形成的。
  3. 可以理解为模板或者设计图纸。
    注意:类在现实世界并不存在,它只是一种对象的数据类型

对象

每个对象具有三个特点：对象的属性，对象的功能和对象的标识。

  1. 对象的属性用来描述对象的基本特征。
  2. 对象的功能用来描述对象的可以完成的操作。
  3. 对象的标识是指每个对象在内存中都有一个唯一的地址值用于与其他对象进行区分，类似于我们的身份证号。

类和对象的关系

  1. 我们先创建类，再通过类创建出对象
  2. 我们可以通过一个类创建出多个对象
  3. 类是抽象的，对象是具体的

11.3 案例1：类的创建使用

通过class关键字创建类，通过new关键字创建对象。

package cn.huo.test11;

/**在一个java文件中可以写多个class`,但是,被public修饰的class只能有一个
 * 而且要求这个公共类的名字必须与文件的名字保持一致*/
public class TestCreateClass {
    public static void main(String[] args) {
        //4.创建汽车类的对象c1
        Car c1 = new Car();
        //5.通过汽车类对象调用汽车类的功能
        c1.start();
        c1.brake();
        //6.通过汽车类对象打印查看属性值
        System.out.println(c1.brand); //null
        System.out.println(c1.price); //0.0
        System.out.println(c1.color); //null

    }
}

//1.通过class关键字创建汽车类--用来描述汽车这一类事物--属性+功能
class Car{
    //2.定义汽车类的属性--用成员变量来描述--位置:类里方法外
    String brand; //品牌
    double price; //价格
    String color; //颜色

    //3.定义汽车类的功能--用方法来描述--格式:修饰符 返回值类型 方法名(参数列表){方法体}
    public void start(){
        System.out.println("汽车点火，启动");
    }

    public void brake(){
        System.out.println("汽车刹车");
    }

}

11.4 案例1.2：创建多个对象

package cn.huo.test11;

/**在一个java文件中可以写多个class`,但是,被public修饰的class只能有一个
 * 而且要求这个公共类的名字必须与文件的名字保持一致*/
public class TestCreateClass {
    public static void main(String[] args) {
        //4.创建汽车类的对象c1
        Car c1 = new Car();
        //5.通过汽车类对象调用汽车类的功能
        c1.start();
        c1.brake();
        //6.通过汽车类对象打印查看属性值
        System.out.println(c1.brand); //null
        System.out.println(c1.price); //0.0
        System.out.println(c1.color); //null
        System.out.println("================================");
        //7.创建汽车类的第2个对象c2
        Car c2=new Car();
        //8.通过c2对象,调用Car类的2个方法
        c2.start();
        c2.brake();
        //9.给c2对象的3个属性赋值
        c2.brand="奥迪A6L";
        c2.price=40.5;
        c2.color="黑色";
        //10.打印查看c2对象的3个属性值
        System.out.println("品牌："+c2.brand);
        System.out.println("价格(W)："+c2.price);
        System.out.println("颜色："+c2.color);
        //11.查看两个对象的地址值
        System.out.println(c1);
        System.out.println(c2);
    }
}

//1.通过class关键字创建汽车类--用来描述汽车这一类事物--属性+功能
class Car{
    //2.定义汽车类的属性--用成员变量来描述--位置:类里方法外
    String brand; //品牌
    double price; //价格
    String color; //颜色

    //3.定义汽车类的功能--用方法来描述--格式:修饰符 返回值类型 方法名(参数列表){方法体}
    public void start(){
        System.out.println("汽车点火，启动");
    }

    public void brake(){
        System.out.println("汽车刹车");
    }

}

11.5 案例2

创建School类
在这里插入图片描述

package cn.huo.test11;

public class School {
    String schoolName; //中心名称
    int classNumber; //教室数目
    int labNumber;  //机房数目

    public void showCenter(){
        System.out.println(schoolName + "培训学员\n" + "配备："
                + classNumber + "教" + labNumber + "机");
    }
}

创建对象
在这里插入图片描述

package cn.huo.test11;

public class TestSchool {
    public static void main(String[] args) {
        //创建对象 类名 对象名=new 类名();
        School center = new School();
        System.out.println("初始化成员变量前");
        //引用类的方法：对象名.方法名()
        center.showCenter();

        //引用类的属性：对象名.属性
        center.schoolName="北京中心";
        center.classNumber=10;
        center.labNumber=10;
        System.out.println("\n初始化成员变量后");
        center.showCenter();
    }
}

11.6 案例3

在这里插入图片描述
创建学员类

package cn.huo.test11;

public class Student {
    String name;	//姓名
    int age;		//年龄
    String classNo;	//班级
    String hobby;	//爱好

    public void show(){
        System.out.println(name + "\n年龄：" + age + "\n就读于：" +
                classNo + "\n爱好：" + hobby);
    }
}

创建教员类

package cn.huo.test11;

public class Teacher {
    String name;	//姓名
    String major;	//专业方向
    String courses;	//教授课程
    int schoolAge;	//教龄

    //输出信息方法
    public void show(){
        System.out.println(name + "\n专业方向：" + major +
                "\n教授课程：" + courses + "\n教龄：" + schoolAge);
    }
}

测试学员于教员类

package cn.huo.test11;

public class TestStudentTeacher {
    public static void main(String[] args) {
        //创建学员对象
        Student student = new Student();
        student.name = "张浩";				//给各个属性赋值
        student.age = 10;
        student.classNo = "S1班";
        student.hobby = "篮球";
        student.show();						//调用方法

        System.out.println("========分割线=========");
        //创建教员对象
        Teacher teacher = new Teacher();
        teacher.name = "王老师";				//给各个属性赋值
        teacher.major = "计算机";
        teacher.courses = "使用Java语言理解程序逻辑";
        teacher.schoolAge = 5;
        teacher.show();						//调用方法
    }
}

十二、类的无参方法

12.1 编写电池类

创建电池类 Cell

package cn.oop.test12;

public class Cell {
    String callType; //品牌

    //续电方法
    public void continued(){
        System.out.println(callType+"电池续电超级好");

    }
}

测试电池类 TestCell

package cn.oop.test12;

public class TestCell {
    public static void main(String[] args) {
        Cell cell = new Cell(); //创建电池对象
        cell.callType="南孚"; //给品牌属性赋值
        cell.continued(); //调用续电方法
    }
}

12.2 计算平均分和总成绩

创建成绩类 Score

package cn.oop.test12;

public class Score {
    double javaScore; //java成绩 
    double cScore; //c成绩
    double dBScore; //数据库成绩

    /* 计算成绩总分 */
    public double sum(){
        double sumScore=javaScore+cScore+dBScore;
        return sumScore;
    }
    
    /* 计算成绩平均分 */
    public double avg(){
        double sumScore=sum();
        return sumScore/3;
    }
}

测试计算成绩类 TestScore

package cn.oop.test12;

import java.util.Scanner;

public class TestScore {
    public static void main(String[] args) {
        Scanner input = new Scanner(System.in);
        Score s1 = new Score(); //创建对象
        System.out.print("请输入java成绩：");
        s1.javaScore=input.nextDouble(); //为java成绩属性赋值
        System.out.print("请输入C#成绩：");
        s1.cScore=input.nextDouble();  //为c成绩属性赋值
        System.out.print("请输入DB成绩：");
        s1.dBScore=input.nextDouble();  //为数据库成绩属性赋值

        System.out.println("总成绩是："+s1.sum()); //调用计算成绩总分方法
        System.out.println("平均成绩是："+s1.avg()); //调用计算成绩平均分方法
    }
}

12.3 编写手机类

创建手机类 Phone

package cn.oop.test12;

public class Phone {
    
    /* 下载音乐方法 */
    public void download(){
        System.out.println("下载音乐中.....");
    }

    /* 播放音乐方法 */
    public void play(){
        System.out.println("播放刚刚好--薛之谦");
    }

    /* 电池续电方法 */
    public void reusingCell(){
        Cell cell = new Cell(); //创建电池类对象
        cell.continued();  //调用续电方法
    }
}

测试手机类 TestPhone

package cn.oop.test12;

public class TestPhone {
    public static void main(String[] args) {
        Phone phone = new Phone(); //创建手机对象
        phone.download();  //调用下载方法
        phone.play();  //调用播放方法
        phone.reusingCell();  //调用续电方法
    }
}

12.4 定义管理员类

创建管理员类 Manager

package cn.oop.test12.homeWork;

public class Manager {
    String name="admin";  //管理员用户名
    String password="123456";  //密码
    
    /* 打印管理员信息方法 */
     public String show(){
         return "管理员信息用户名为："+name+"  密码为："+password;
     }
}

测试管理员类 TestManager

package cn.oop.test12.homeWork;

public class TestManager {
    public static void main(String[] args) {
        Manager m1 = new Manager();
        System.out.println(m1.show());
    }
}

12.5 实现菜单的级联效果

创建类 Menu

package cn.oop.test12.homeWork;

import java.util.Scanner;

public class Menu {

    /**
     * 显示登录菜单
     */
    public void showLoginMenu(){
        System.out.println("\n\t欢迎使用我行我素购物管理系统\n");
        System.out.println("\t\t 1. 登 录 系 统\n");
        System.out.println("\t\t 2. 退 出\n");
        System.out.println ("* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *");
        System.out.print("请选择,输入数字:");
    }

    /**
     * 显示主菜单
     */
    public void showMainMenu(){
        System.out.println("\n\t我行我素购物管理系统主菜单\n");
        System.out.println("* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *\n");
        System.out.println("\t\t 1. 客 户 信 息 管 理\n");
        System.out.println("\t\t 2. 真 情 回 馈\n");
        System.out.println("* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *");
        System.out.print("请选择,输入数字或按0返回上一级菜单:");
        boolean con;
        do{
            con = false;
            /*输入数字，选择菜单*/
            Scanner input = new Scanner(System.in);
            int no = input.nextInt();
            if (no == 1){
                showCustMMenu();
            }else if (no == 2){
                showSendGMenu();
            }else if (no == 0){
                showLoginMenu();
            }else{
                System.out.print("输入错误, 请重新输入数字：");
                con = true;
            }
        }while(con);
    }

    /**
     * 显示客户管理菜单
     */
    public void showCustMMenu(){
        System.out.println("\n\t我行我素购物管理系统 > 客户信息管理");
        System.out.println("* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *\n");
        System.out.println("\t\t  1. 显 示 所 有 客 户 信 息\n");
        System.out.println("\t\t  2. 添 加 客 户 信 息\n");
        System.out.println("\t\t  3. 修 改 客 户 信 息\n");
        System.out.println("\t\t  4. 查 询 客 户 信 息\n");
        System.out.println("* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *");
        System.out.print("请选择,输入数字或按0返回上一级菜单:");

        /*输入数字，选择菜单*/
        boolean con;
        do{
            con = false;
            Scanner input = new Scanner(System.in);
            int no = input.nextInt();
            if(no == 1){
                System.out.println("执行显示所有客户信息");
            }else if(no == 2){
                System.out.println("执行添加客户信息");
            }else if(no == 3){
                System.out.println("执行修改客户信息");
            }else if(no == 4){
                System.out.println("执行查询客户信息");
            }else if(no == 0){
                showMainMenu();// 返回主菜单
            }else{
                System.out.print("输入错误, 请重新输入数字：");
                con = true;
            }
        }while(con);
    }
    /**
     * 显示真情回馈菜单
     */
    public void showSendGMenu(){
        System.out.println("\n\t我行我素购物管理系统 > 真情回馈");
        System.out.println("* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *\n");
        System.out.println("\t\t 1. 幸 运 大 放 送\n");
        System.out.println("\t\t 2. 幸 运 抽 奖\n");
        System.out.println("\t\t 3. 生 日 问 候\n");
        System.out.println("* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *");
        System.out.print("请选择,输入数字或按0返回上一级菜单：");
        boolean con;
        do{
            con = false;
            /*输入数字，选择菜单*/
            Scanner input = new Scanner(System.in);
            int no = input.nextInt();
            if(no == 1){
                System.out.println("执行幸运大放送");
            }else if(no == 2){
                System.out.println("执行幸运抽奖");
            }else if(no == 3){
                System.out.println("执行生日问候");
            }else if(no == 0){
                showMainMenu();  // 返回主菜单
            }else{
                System.out.print("输入错误,请重新输入数字：");
                con = true;
            }
        }while(con);
    }
}

测试Menu类 StartSMS

package cn.oop.test12.homeWork;

import java.util.Scanner;

public class StartSMS {

    public static void main(String[] args) {
        /*初始化系统管理员*/
        Manager manager = new Manager();
        boolean con=true;
        do{
            /*显示登录菜单*/
            Menu menu = new Menu();
            menu.showLoginMenu();

            /*实现菜单*/
            Scanner input = new Scanner(System.in);
            int choice = input.nextInt();
            switch(choice){
                case 1:
                    /*密码验证*/
                    System.out.print("请输入用户名：");
                    String name = input.next();
                    System.out.print("请输入密码：");
                    String psw = input.next();
                    if(name.equals(manager.name)&& psw.equals(manager.password)){
                        System.out.println("@@登录成功："+manager.name+"@@");
                        menu.showMainMenu();
                    }else{
                        System.out.println("@@您没有权限进入系统，请重新登录。@@");
                    }
                    break;
                case 2:
                    System.out.println("谢谢您的使用！");
                    con=false;
                    break;
            }
        }while(con);
    }
}

十三、人机猜拳

13.1 创建用户类 Person

package cn.oop.test13;
import java.util.Scanner;

public class Person {
    String name = "匿名";  // 名字
    int score = 0;         // 积分

    /*出拳方法*/
    public int showFist(){
        // 接收用户的选择
        Scanner input = new Scanner(System.in);
        System.out.print("\n请出拳:1.剪刀 2.石头 3.布 (输入相应数字) :");
        int show = input.nextInt();

        // 输出出拳结果，并返回
        switch(show){
            case 1:
                System.out.println("你出拳: 剪刀");
                break;
            case 2:
                System.out.println("你出拳: 石头");
                break;
            case 3:
                System.out.println("你出拳: 布");
                break;
        }
        return show;
    }
}

测试用户类 TestPerson

package cn.oop.test13;

public class TestPerson {
    public static void main(String[] args) {
        Person p1 = new Person();
        int num = p1.showFist();
        System.out.println(num);
    }
}

13.2 创建计算机类 Computer

package cn.oop.test13;

import java.util.Random;

public class Computer {
    String name = "电脑"; // 名字
    int score = 0;;       // 积分

    /*出拳方法*/
    public int showFist(){
        // 产生随机数
        int show = new Random().nextInt(3)+1;  //产生随机数，表示电脑出拳

        // 输出出拳结果并返回
        switch(show){
            case 1:
                System.out.println(name+"出拳: 剪刀");
                break;
            case 2:
                System.out.println(name+"出拳: 石头");
                break;
            case 3:
                System.out.println(name+"出拳: 布");
                break;
        }
        return show;
    }
}

测试计算机类 TestComputer

package cn.oop.test13;

public class TestComputer {
    public static void main(String[] args) {
        Computer c1 = new Computer();
        System.out.println(c1.showFist());
    }
}

13.3 创建游戏类 Game

package cn.oop.test13;
import java.util.Scanner;

public class Game {
    Person person;       //玩家方
    Computer computer;   //机器方
    int count;           //对战次数

    /* 初始化 */
    public void initial(){
        person = new Person();
        computer = new Computer();
        count = 0;
    }

    /*开始游戏*/
    public void startGame() {
        initial();
        System.out.println("----------------欢 迎 进 入 游 戏 世 界----------------\n");
        System.out.println("\n\t\t******************");
        System.out.println  ("\t\t**  猜拳, 开始    **");
        System.out.println  ("\t\t******************");

        System.out.println("\n\n出拳规则：1.剪刀 2.石头 3.布");
        /*选择对方角色*/
        System.out.print("请选择对方角色（1：刘备 2：孙权 3：曹操）： ");
        Scanner input = new Scanner(System.in);
        int role = input.nextInt();
        if(role == 1){
            computer.name = "刘备";
        }else if(role == 2){
            computer.name = "孙权";
        }else if(role == 3){
            computer.name = "曹操";
        }

        System.out.print("你选择了"+computer.name+"对战");
    }
}

测试游戏类 TestGame

package cn.oop.test13;

public class TestGame {
    public static void main(String[] args) {
        Game game = new Game();
        game.initial();
        game.startGame();
    }
}

13.4 实现一局对战

修改Game类

package cn.oop.test13;
import java.util.Scanner;

public class Game {
    Person person;       //甲方
    Computer computer;   //乙方
    int count;           //对战次数

    /* 初始化 */
    public void initial(){
        person = new Person();
        computer = new Computer();
        count = 0;
    }

    /*开始游戏*/
    public void startGame() {
        initial();  // 初始化
        System.out.println("----------------欢 迎 进 入 游 戏 世 界----------------\n");
        System.out.println("\n\t\t******************");
        System.out.println  ("\t\t**  猜拳, 开始    **");
        System.out.println  ("\t\t******************");

        System.out.println("\n\n出拳规则：1.剪刀 2.石头 3.布");
        /*选择对方角色*/
        System.out.print("请选择对方角色（1：刘备 2：孙权 3：曹操）： ");
        Scanner input = new Scanner(System.in);
        int role = input.nextInt();
        if(role == 1){
            computer.name = "刘备";
        }else if(role == 2){
            computer.name = "孙权";
        }else if(role == 3){
            computer.name = "曹操";
        }
        System.out.println("你选择了 "+computer.name+"对战");

        /*开始游戏*/
        System.out.print("\n要开始吗？（y/n） ");
        String con = input.next();
        int perFist;   //用户出的拳
        int compFist;  //计算机出的拳
        if(con.equals("y")){
            /*出拳*/
            perFist = person.showFist();
            compFist = computer.showFist();
            /*裁决*/
            if(perFist == compFist){
                System.out.println("结果说:和局,真衰！\n");  //平局
            }else if((perFist == 1 && compFist == 3) || (perFist == 2  && compFist == 1) || (perFist == 3 && compFist == 2)){
                System.out.println("结果说： 恭喜， 你赢了！");  //用户赢
            }else{
                System.out.println("结果说:^_^,你输了，真笨!\n");  //计算机赢
            }
        }
    }
}

继续用TestGame类进行测试

13.5 实现循环对战，并累计得分

修改Game类

package cn.oop.test13;
import java.util.Scanner;

public class Game {
    Person person;       //甲方
    Computer computer;   //乙方
    int count;           //对战次数

    /* 初始化 */
    public void initial(){
        person = new Person();
        computer = new Computer();
        count = 0;
    }

    /*开始游戏*/
    public void startGame() {
        initial();  // 初始化
        System.out.println("----------------欢 迎 进 入 游 戏 世 界----------------\n");
        System.out.println("\n\t\t******************");
        System.out.println  ("\t\t**  猜拳, 开始    **");
        System.out.println  ("\t\t******************");

        System.out.println("\n\n出拳规则：1.剪刀 2.石头 3.布");
        /*选择对方角色*/
        System.out.print("请选择对方角色（1：刘备 2：孙权 3：曹操）： ");
        Scanner input = new Scanner(System.in);
        int role = input.nextInt();
        if(role == 1){
            computer.name = "刘备";
        }else if(role == 2){
            computer.name = "孙权";
        }else if(role == 3){
            computer.name = "曹操";
        }
        System.out.println("你选择了 "+computer.name+"对战");

        /*开始游戏*/
        System.out.print("\n要开始吗？（y/n） ");
        String con = input.next();
        int perFist;   //用户出的拳
        int compFist;  //计算机出的拳
        while(con.equals("y")){
            /*出拳*/
            perFist = person.showFist();
            compFist = computer.showFist();
            /*裁决*/
            if(perFist == compFist){
                System.out.println("结果:和局,真衰！嘿嘿,等着瞧吧 !\n");  //平局
            }else if((perFist == 1 && compFist == 3) || (perFist == 2  && compFist == 1) || (perFist == 3 && compFist == 2)){
                System.out.println("结果： 恭喜， 你赢了！");  //用户赢
                person.score++;
            }else{
                System.out.println("结果说:^_^,你输了，真笨!\n");  //计算机赢
                computer.score++;
            }
            count++;
            System.out.print("\n是否开始下一轮（y/n）:  ");
            con = input.next();
        }
    }
}

继续用TestGame类进行测试

13.6 显示对战结果

修改Game类
在 startGame() 中 while循环外添加 showResult() 方法调用
在这里插入图片描述
在Game类 中添加方法

/* 显示比赛结果 */
    public void showResult(){
        /*显示最后结果*/
        System.out.println("---------------------------------------------------");
        System.out.println(computer.name + "  VS  " + person.name);
        System.out.println("对战次数："+ count);

		/*显示对战结果*/
        int result = calcResult();
        if(result == 1){
            System.out.println("结果：打成平手，下次再和你一分高下！");
        }else if(result == 2){
            System.out.println("结果：恭喜恭喜！");   //用户获胜
        }else{
            System.out.println("结果：呵呵，笨笨，下次加油啊！");   //计算机获胜
        }
        System.out.println("---------------------------------------------------");
    }

    /* 计算比赛结果 */
    public int calcResult(){
        if(person.score == computer.score){
            return 1; // 战平
        }else if(person.score > computer.score){
            return 2; // 用户赢
        }else{
            return 3; // 电脑赢
        }

    }

继续用TestGame类进行测试

13.7 显示用户与机器得分

修改 Game 类中 showResult() 方法

public void showResult(){
        /*显示最后结果*/
        System.out.println("---------------------------------------------------");
        System.out.println(computer.name + "  VS  " + person.name);
        System.out.println("对战次数："+ count);

        //显示最终的得分
        System.out.println("\n姓名\t得分");
        System.out.println(person.name+"\t"+person.score);
        System.out.println(computer.name+"\t"+computer.score+"\n");

        //显示对战结果
        int result = calcResult();
        if(result == 1){
            System.out.println("结果：打成平手，下次再和你一分高下！");
        }else if(result == 2){
            System.out.println("结果：恭喜恭喜！");   //用户获胜
        }else{
            System.out.println("结果：呵呵，笨笨，下次加油啊！");   //计算机获胜
        }
        System.out.println("---------------------------------------------------");
    }

用TestGame类进行测试

十四 带参数的方法

14.1 榨汁机

创建榨汁机类 ZhaZhiJi

package cn.oop.test14;

public class ZhaZhiJi {

    /* 榨汁方法 */
    public String zhaZhi(String fruit){
        String juice=fruit+"汁";
        return juice;
    }
}

测试榨汁机类 TestZhaZhiJi

package cn.oop.test14;

public class TestZhaZhiJi {
    public static void main(String[] args) {
        ZhaZhiJi z1 = new ZhaZhiJi();
        String pg = z1.zhaZhi("苹果");
        System.out.println(pg);
        String bl = z1.zhaZhi("菠萝");
        System.out.println(bl);
    }
}

14.2 带一个参数的方法

创建班级类 StudentsBiz

package cn.oop.test14;

public class StudentsBiz {
    String[] stuName=new String[30];//存放学生姓名

    //添加学生姓名方法
    public void addName(String name){
        /*将班级学生姓名存放到数组中*/
        for(int i=0;i< stuName.length; i++){
            /* 没有存放姓名的位置才能存放 */
            if(stuName[i]==null){
                stuName[i]=name;
                break;
            }
        }
    }

    //打印班级学生姓名
    public void showName(){
        for (int i=0; i<stuName.length; i++){
            System.out.print(stuName[i]+" ");
        }
    }
}

测试班级类 TestStudentsBiz

package cn.oop.test14;

public class TestStudentsBiz {
    public static void main(String[] args) {
        StudentsBiz rj1 = new StudentsBiz();
        rj1.addName("张三"); //添加学生姓名
        rj1.addName("李四");
        rj1.addName("王五");
        rj1.showName();  //查看班级学生姓名
    }
}

14.3 带多个参数的方法

在 StudentsBiz 类中添加方法

//在一个范围内查找学生是否存在
    public boolean searchName(int start,int end,String name){
        boolean find = false;  // 是否找到标识

        // 指定区间数组中，查找姓名
        for(int i=start-1;i<end;i++){
            if(name.equals(stuName[i])){
                find=true; //找到后将标识设置为true
                break;
            }
        }
        return find;
    }

测试班级类 TestStudentsBiz

package cn.oop.test14;

public class TestStudentsBiz {
    public static void main(String[] args) {
        StudentsBiz rj1 = new StudentsBiz();
        rj1.addName("张三"); //添加学生姓名
        rj1.addName("李四");
        rj1.addName("王五");
        rj1.showName();  //查看班级学生姓名

        //测试多个参数方法
        boolean tf = rj1.searchName(2, 10, "张三");
        if(tf){
            System.out.println("\n存在");
        }else {
            System.out.println("\n没有找到");
        }
    }
}

14.4 客户姓名添加和显示

创建客户类 CustomerBiz

package cn.oop.test14.homeWork;

public class CustomerBiz {
    String[] names = new String[30];  // 姓名数组

    /* 添加姓名 */
    public void addName(String name){
        for(int i =0;i<names.length;i++){
            if(names[i]==null){
                names[i]=name;
                break;
            }
        }
    }

    /* 打印所有客户姓名 */
    public void showNames(){
        System.out.println("**************************");
        System.out.println("\t客户姓名列表：");
        System.out.println("**************************");
        for(int i =0;i<names.length;i++){
            if(names[i]!=null){
                System.out.print(names[i]+"\t");
            }
        }
        System.out.println();
    }
}

测试客户类 TestCustomerBiz

package cn.oop.test14.homeWork;

import java.util.Scanner;

public class TestCustomerBiz {
    public static void main(String[] args) {
        CustomerBiz cb=new CustomerBiz();
        boolean con=true; //判断是否继续
        Scanner input = new Scanner(System.in);

        while(con){
            System.out .print("请输入客户的姓名：");
            String newName = input.next();
            cb.addName(newName);
            System.out .print("继续输入吗？（y/n）：");
            String choice=input.next();
            if(choice.equals("n")){
                con=false;
            }
        }
        cb.showNames();
    }
}

14.5 修改客户姓名

在 CustomerBiz 类中添加方法

/* 修改客户姓名 */
    public boolean editName(String oldName,String newName){
        boolean find = false;  // 是否找到并修改成功标识

        // 循环数组，找到姓名为oldName的元素，修改为newName
        for(int i=0;i<names.length;i++){
            if(oldName.equals(names[i])){
                names[i] = newName;
                find=true;
                break;
            }
        }
        return find;
    }

测试修改客户姓名方法 TestCustomerBiz2

package cn.oop.test14.homeWork;

import java.util.Scanner;

public class TestCustomerBiz2 {
    public static void main(String[] args) {
        CustomerBiz cb=new CustomerBiz();
        Scanner input = new Scanner(System.in);

        for (int i=1; i<=5; i++){
            System.out .print("请输入客户的姓名：");
            String newName = input.next();
            cb.addName(newName);
        }
        cb.showNames();

        System.out .print("\n请输入要修改的客户姓名：");
        String oldName = input.next();
        System.out .print("请输入新的客户姓名：");
        String newName = input.next();
        boolean edit = cb.editName(oldName, newName);
        System.out.println("\n\n*****修改结果*****");
        if(edit){
            System.out.println("找到并修改成功");
        }else {
            System.out.println("修改失败");
        }

        cb.showNames();
    }
}

14.6 数组作为参数的方法

创建成绩类 Score

package cn.oop.test14;

public class Score {

    //计算平均分
    public  double avgScore(int[] score){
        int sum=0;
        for (int i=0; i<score.length; i++){
            sum+=score[i];
        }
        double avg=sum/score.length;
        return avg;
    }

    //计算最高分
    public  int maxScore(int[] score){
        int max=score[0];
        for(int i=0; i<score.length; i++){
            if(max<score[i]){
                max=score[i];
            }
        }
        return max;
    }
}

测试成绩类 TestScore

package cn.oop.test14;

import java.util.Scanner;

public class TestScore {
    public static void main(String[] args) {
        Scanner input = new Scanner(System.in);
        Score s1 = new Score();

        int[] score=new int[5];
        System.out.println("请输入五名参赛者的成绩：");
        for(int i=0; i<5; i++){
            score[i]=input.nextInt();
        }

        double avg = s1.avgScore(score);
        System.out.println("平均成绩： "+avg);
        int max = s1.maxScore(score);
        System.out.println("最高成绩： "+max);
    }
}

14.7 对象作为参数的方法

创建学生类 Student

package cn.oop.test14.stu;

public class Student {
    
    int id; //编号
    String name; //姓名
    int age; //年龄
    int score; //成绩
    
    //打印学生信息
    public void show(){
        System.out.println(id+"\t"+name+"\t"+age+"\t"+score);
    }
}

创建班级类

package cn.oop.test14.stu;

public class StuClass {
    //创建学生数组
    Student[] students=new Student[30];

    /* 增加学生 */
    public void addStudent(Student stu){
        for(int i =0;i<students.length;i++){
            if(students[i]==null){
                students[i]=stu;
                break;
            }
        }
    }
    
    /* 显示本班的学生信息 */
    public void showStudents(){
        System.out.println("本班学生列表：");
        for(int i =0;i<students.length;i++){
            if(students[i]!=null){
                students[i].show();
            }
        }
        System.out.println();
    }
}

测试学生类以及班级类

package cn.oop.test14.stu;

import cn.oop.test14.StudentsBiz;

public class TestStu {
    public static void main(String[] args) {
        //实例化学生对象
        Student s1=new Student();
        s1.id=10;
        s1.name="哈哈";
        s1.age=18;
        s1.score=99;
        Student s2=new Student();
        s2.id=11;
        s2.name="呵呵";
        s2.age=19;
        s2.score=60;
        //新增学生对象
        StuClass studentsBiz=new StuClass();
        studentsBiz.addStudent(s1);
        studentsBiz.addStudent(s2);
        studentsBiz.showStudents();//显示学生信息
    }
}

14.8 对客户姓名排序

创建客户类 Customer

package cn.oop.test14.homeWork;

import java.util.Arrays;

public class Customer {

    //排序方法
    public String[] sortNames(String[] names) {
        Arrays.sort(names);
        return names;
    }
}

测试客户类 TestCustomer

package cn.oop.test14.homeWork;

public class TestCustomer {
    public static void main(String[] args) {
        Customer st = new Customer();
        String[] str = new String[] { "Tom", "Jack", "Merry", "Smith","Sunny" };
        System.out.println("****排序前****");
        for (int i = 0; i < str.length; i++) {
            System.out.print(str[i] + "\t");
        }
        //调用排序方法
        st.sortNames(str);
        System.out.println("\n****排序后****");
        for (int i = 0; i < str.length; i++) {
            System.out.print(str[i] + "\t");
        }
    }
}

14.9 改进客户信息的添加和显示

修改客户类添加属性和方法 Customer

package cn.oop.test14.homeWork;

import java.util.Arrays;

public class Customer {

    public String name; //姓名
    public int age; //年龄
    public boolean isMember; //是否有会员卡

    //打印客户信息
    public void show() {
        System.out.println(name + "\t" + age + "\t" + isMember);
    }
    //排序方法
    public String[] sortNames(String[] names) {
        Arrays.sort(names);
        return names;
    }
}

创建Customers类 声明客户对象数组

package cn.oop.test14.homeWork;

public class Customers {
    Customer[] customers = new Customer[30]; // 客户数组

    /* 增加客户 */
    public void addCustomer(Customer cust) {
        for (int i = 0; i < customers.length; i++) {
            if (customers[i] == null) {
                customers[i] = cust;
                break;
            }
        }
    }

    /* 显示客户信息 */
    public void showCustomers() {
        System.out.println("客户信息：");
        for (int i = 0; i < customers.length; i++) {
            if (customers[i] != null) {
                customers[i].show();
            }
        }
        System.out.println();
    }
}

创建测试类 TestCust

package cn.oop.test14.homeWork;

public class TestCust {
    public static void main(String[] args) {
        // 实例化客户对象
        Customer c1 = new Customer();
        c1.name = "哈哈";
        c1.age = 30;
        c1.isMember = false;

        Customer c2 = new Customer();
        c2.name = "呵呵";
        c2.age = 19;
        c2.isMember = true;

        // 新增客户对象
        Customers customers = new Customers();
        customers.addCustomer(c1);
        customers.addCustomer(c2);
        customers.showCustomers();// 显示客户信息
    }
}

十五 字符串

15.1 字符串长度

package cn.oop.test15;

import java.util.Scanner;

public class StringDemo01 {
    public static void main(String[] args) {
        Scanner input = new Scanner(System.in);
        String uname,pwd;

        System.out.print("请输入用户名： ");
        uname=input.next();
        System.out.print("请输入密码： ");
        pwd=input.next();

        if(pwd.length()>=6){
            System.out.print("注册成功！ ");
        }else{
            System.out.print("密码长度不能小于6位！");
        }

    }
}

15.2 字符串比较(一）

package cn.oop.test15;

import java.util.Scanner;

public class StringDemo02 {
    public static void main(String[] args) {
        Scanner input = new Scanner(System.in);
        String uname,pwd;

        System.out.print("请输入用户名： ");
        uname=input.next();
        System.out.print("请输入密码： ");
        pwd=input.next();

        if(uname.equals("Huo")&&pwd.equals("123456")){
            System.out.print("登录成功！ ");
        }else{
            System.out.print("用户名或密码不匹配，登录失败！");
        }

    }
}

15.3 字符串比较(二）

package cn.oop.test15;

public class StringDemo03 {
    public static void main(String[] args) {
        String s1="Huo";
        String s2="HUO";
        System.out.println(s1==s2); //false
        System.out.println(s1.equalsIgnoreCase(s2)); //true
        System.out.println(s1.toLowerCase()); //huo
        System.out.println(s2.toUpperCase()); //HUO
    }
}

15.4 实现会员注册（一）

package cn.oop.test15.homeWork;

import java.util.Scanner;

public class Demo1 {

    public static void main(String[] args) {
        Scanner input = new Scanner(System.in);
        String uname,p1,p2;
        boolean resp=false;

        System.out.println("***欢迎进入注册系统*** \n");
        do{
            System.out.print("请输入用户名： ");
            uname=input.next();
            System.out.print("请输入密码： ");
            p1=input.next();
            System.out.print("请再次输入密码： ");
            p2=input.next();
            resp=verify(uname, p1, p2);
        }while(!resp);
    }

    public static boolean verify(String name,String pwd1,String pwd2){
        boolean flag=false;
        if(name.length()<3 || pwd1.length()<6){
            System.out.println("用户名长度不能小于3，密码长度不能小于6！");
        }else if(!pwd1.equals(pwd2)){
            System.out.println("两次输入的密码不相同！");
        }else{
            System.out.println("注册成功！请牢记用户名和密码。");
            flag=true;
        }
        return flag;
    }
}

15.5 字符串连接

package cn.oop.test15;

public class StringDemo04 {
    public static void main(String[] args) {
        int sqlScore = 80;        	//SQL成绩
        int javaScore = 90;       	//Java成绩
        double htmlScore = 86.7;  	//HTML成绩

        /* 方法一 */
        String scoreSheet = "SQL:" + sqlScore + "  Java:" + javaScore  + "  HTML:" + htmlScore; //成绩单
        //打印成绩单
        System.out.println("*****成绩单*****");
        System.out.println(scoreSheet);

        /* 方法二 */
        String name="Java; ";
        String name2="sqL; ";
        System.out.println(name.concat(name2));
        /* 错误写法
         * System.out.println(name.concat(javaScore));
         * */
    }
}

15.6 字符串常用提取方法

package cn.oop.test15;

public class StringDemo05 {
    public static void main(String[] args) {
        String s1 = "abcbdbba";
        System.out.println(s1.indexOf("b"));//1,返回本字符串中指定元素第一次出现的下标
        System.out.println(s1.indexOf("cb"));//2,返回本字符串中指定元素第一次出现的下标
        System.out.println(s1.lastIndexOf("b"));//6,返回本字符串中指定元素最后一次出现的下标
        System.out.println(s1.lastIndexOf("bb"));//6,返回本字符串中指定元素最后一次出现的下标

        String s2 = "abcdefgh";
        System.out.println(s2.substring(3));//defgh,从指定下标处截取子字符串[3,结束]
        System.out.println(s2.substring(3,6));//def,从指定下标处截取子字符串[3,6)含头不含尾

        String s3="  h  u  o  ";
        System.out.println(s3.trim());//去除字符开头与末尾的空格

        String s4="啊哈哈哈";
        System.out.println(s4.charAt(1)); //b; 根据下标获取字符，取到的值为char类型

        m();
    }

    private static void m() {
        String word = "Hello,      ";
        word = word.trim(); //Hello,
        String s = word.concat("小鱼儿!"); //Hello,小鱼儿!
        int index1 = s.indexOf(','); //5
        int index2 = s.indexOf('!'); //9
        System.out.println(s.substring(index1+1,index2 ));
    }
}

15.7 字符串拆分

package cn.oop.test15;

public class StringDemo06 {
    public static void main(String[] args) {
        String words="长亭外 古道边 芳草碧连天 晚风扶 柳笛声残 夕阳山外山";

        System.out.println("***原歌词格式***\n"+words);
        System.out.println("\n***拆分后歌词格式***");
        String[] printWord=words.split(" ");//按照空格进行拆分
        for(int i=0;i<printWord.length;i++){
            System.out.println(printWord[i]);//打印输出
        }

    }
}

15.8 验证身份证号，电话号

package cn.oop.test15.homeWork;

public class Demo02 {
    public static void main(String[] args) {
        String sfz="140430199803125600";
        String phone="18734510830";
        String zj="0350-7187064";
        System.out.println(sfz.matches("^[1-9]\\d{5}(18|19|([23]\\d))\\d{2}((0[1-9])|(10|11|12))(([0-2][1-9])|10|20|30|31)\\d{3}[0-9Xx]$"));
        System.out.println(phone.matches("^(13[0-9]|14[5|7]|15[0|1|2|3|5|6|7|8|9]|18[0|1|2|3|5|6|7|8|9])\\d{8}$"));
        System.out.println(zj.matches("\\d{3}-\\d{8}|\\d{4}-\\d{7}"));
    }
}

15.9 判断字符出现次数

package cn.oop.test15.homeWork;

public class Demo03 {
    public static void main(String[] args) {

        String s="我爱你中国，我爱你故乡";
        String ch="爱";

        //调用方法，输出结果
        int num=counter(s,ch);
        System.out.print("\""+s+"\"中包含"+num+"个\""+ch+"\"。");
    }

    public static int counter(String s,String ch){
        int num=0;//计数器，初始化0
        String[] temps=new String[s.length()];
        //字符串转换成数组
        for(int i=0;i<temps.length;i++){
            temps[i]=s.substring(i,i+1);
        }
        //比较字母，计数
        for(int j=0;j<temps.length;j++){
            if(temps[j].equals(ch)){
                num++;
            }
        }
        return num;
    }
}

15.10 StringBuffer

package cn.oop.test15;

public class StringDemo07 {
    public static void main(String[] args) {
        StringBuffer sb = new StringBuffer("青春无悔");
        int num=110;
        StringBuffer sb1 = sb.append("我心永恒");
        System.out.println(sb1);
        StringBuffer sb2 = sb1.append('啊');
        System.out.println(sb2);
        StringBuffer sb3 = sb2.append(num);
        System.out.println(sb3);
        System.out.println("=========================");
        StringBuffer s=new StringBuffer("12345678");
        for(int i=s.length()-3; i>0; i=i-3){
            s.insert(i,",");
        }
        System.out.println(s);
    }
}

15.11 StringBuilder和StringBuffer的区别

  1. 在线程安全上 :
    –StringBuffer是旧版本就提供的，线程安全的。@since JDK1.0
    –StringBuilder是jdk1.5后产生，线程不安全的。@since 1.5
  2. 在执行效率上，StringBuilder > StringBuffer > String
  3. 源码体现：本质上都是在调用父类抽象类AbstractStringBuilder来干活，只不过Buffer把代码加了同步关键字，使得程序可以保证线程安全问题。

在这里插入图片描述

在这里插入图片描述

yyds_it_huo
关注
  • 2
    点赞
  • 踩
  • 4
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
JavaSE知识点
m0_69432018的博客
09-17 68
调用yield方法只是一个建议，采用的技术是:写时复制技术/读写分离,添加元素时,使用Lock锁进行锁定,导致当时只能有一个线程对其进行操作,流程是:现将原有的数组复制一份(副本), 新复制的数组比原有的数组长度大1,将新添加的元素放到新的数组中,添加完毕后,用新的数组替换旧的数组。禁止指令重排序: 在对不改变最终的结果的情况下,jvm会对我们写的代码进行重新排序,达到优化的目的，synchronized修饰的方法或者代码块中的代码禁止指令重新排序的，就按照编写的顺序执行,volatile也是可以实现的.
JavaSE基础学习
weixin_74535326的博客
12-18 304
锦苏记录学习java之路
Javase知识体系
11-17
javase部分思维导图，包括数据库，面向对象，集合，io流, 多线程，异常，网络编程
javaSE知识点总结
最新发布
2201_75584542的博客
05-20 205
数据类型[] 数组名 = new 数组类型[数组长度]；数据类型[] 数组名 = new 数据类型[] {数据};数据类型[] 数组名 = {数据1，数据2，… ,数据n}；） [ return 返回值 ];//当反回值类型为void时，没有返回值，不写return语句 }调用方法：方法名称（参数）；形参为定义方法时定义的，此时并没有具体的数值，而实参则为调用方法时赋的具体的值，执行的操作为实参数据拷贝，赋值给形参。
Java SE 基础知识体系梳理
m0_50831101的博客
03-31 417
## Java SE 基础知识体系梳理 ----------day01------------- (1)计算机的体系结构 (2)Java语言的概述 (3)开发环境的搭建和使用 1.计算机的体系结构(常识) 1.1 计算机的基本概念 计算机俗称“电脑”，是一种可以应用于高级计算等各个领域的设备。 计算机主要有两大部分组成：计算机硬件 + 计算机的软件。 1.2 常见的硬件 计算机中常见的硬件主要有：CPU、内存、硬盘、显卡、键盘、鼠标、显示器、… CPU - 中央处理器，是计算机中最核心的部件，类似于人.
JavaSE核心知识点总结
ss810540895的博客
05-04 8679
原文 JavaSE核心知识点总结 一：Java 概述 一、简介 定义：Java 是一门面向对象编程语言，不仅吸收了C++语言的各种优点，还摒弃了C++里难以理解的多继承、指针等概念，因此Java语言具有功能强大和简单易用两个特征。Java语言作为静态面向对象编程语言的代表，极好地实现了面向对象理论，允许程序员以优雅的思维方式进行复杂的编程。应用在桌面应用程序、Web应用程序、分布式系统和嵌入式系统等领域。 发展历程 1996年1月，Sun公司发布了Java的第一个开发工具包*（JDK 1.0）*，
JavaSE基础知识总结(良心详解)
weixin_45799289的博客
04-11 579
Java语言是一种高级编程语言，由Sun Microsystems于1995年首次发布。以下是Java语言的几个主要特点：跨平台性：Java程序可以在不同的操作系统上运行，如Windows、Linux和MacOS等，这是因为Java虚拟机（JVM）负责将Java代码转换成可执行的字节码，并在不同的平台上运行。面向对象：Java是一种面向对象的编程语言，它支持封装、继承和多态等面向对象的编程概念，使得Java程序具有高内聚、低耦合和易于维护的特点。
018-IDEA-javase代码_javase知识学习_javaSEppt_
10-02
JavaSE是java分类中的标准版，是刚接触java要学习的基础知识。JavaEE是java分类中的企业版，是java中的高级，涉及到的知识广泛。JavaME中M是Micro的缩写，用在嵌入式等电子设备中。
JavaSE_JavaSE学习资料_
10-02
这个编程资料包涵盖了JavaSE的学习资源，旨在帮助开发者掌握Java的基础知识、集合框架、IO流等关键概念。 首先，Java基础知识是学习JavaSE的起点。这包括了Java语法、数据类型、控制结构（如if语句、for循环、while...
01-JavaSE知识(学习27天).txt
08-19
27天掌握Javase，超详细，超快学习速度，苏菲超快。
一张图读懂java知识体系
09-08
一张图读懂java知识体系
JAVA知识体系
02-23
JAVA知识图谱，成长为资深工程师必备导航，需要使用mindmanager打开。
彻底了解JAVASE、JAVAEE、JAVAWEB整个的知识体系的6张图
01-11
彻底了解JAVASE、JAVAEE、JAVAWEB整个的知识体系的6张图
JavaSE知识目录.pdf
07-30
JavaSE知识目录，博主精心整理的学习笔记导航，快速定位知识点。
JavaSE知识点思维导图.xmind
07-22
javase学习内容思维导图，自己编写，有些细节没有写出来，自己学习后可以添加，每次看到这图就让我把javase的基础知识回顾一遍，现在记得可牢了！
JavaSE基础知识点
qq_52701502的博客
04-27 236
编程入门(计算机普及/操作系统/万维网)Java语言的应用场景Java基础阶段知识结构拆解(图谱/课程概述/课程体系)软件开发介绍计算机编程语言介绍Java语言概述Java运行机制及运行过程Java的开发环境搭建开发体验HelloWorld常见问题及解决办法注释良好的编程风格常用的Java开发工具关键字标识符变量运算符键盘接收用户输入语言：是人与人之间用于沟通的一种方式。例如：中国人与中国人用普通话沟通。而中国人要和英国人交流，就要学习英语。
JavaSE知识体系
m0_60684456的博客
03-16 93
│ ├── 变量、数据类型。├── Lambda表达式。│ ├── 控制语句。│ ├── 类和对象。│ └── 异常处理。│ ├── 线程安全。│ ├── 运算符。│ ├── 字节流。│ ├── 字符流。│ ├── 缓冲流。│ ├── 数据流。│ ├── 线程池。│ ├── 数组。
JavaSE基础 (全网最全知识点)
不吃紫菜的博客
02-27 669
背景介绍 java运行机理(即使编译型语言，又是解释型语言) 编译型语言(如：c语言) 源代码需要通过预编译形成可执行文件，再由系统执行该文件形成可识别的二进制文件 解释型语言 边执行边转换。源代码先翻译成中间代码，解释器(类似于JVM)再对中间代码进行解释运行，每执行一次都要翻译一次。 标识符规则： 标识符只能由大小写字母、数字、下划线(_)和美元符号($)组成，但是不能...
Java学习10.12 - 10.28 知识点总结
a931394057的博客
10-29 622
-10.28 学习总结
javase学习的知识点
04-02
1. Java基础语法 2. 面向对象编程 3. 异常处理 4. 泛型 5. 集合 6. 输入输出流 7. 多线程 8. JDBC数据库操作 9. XML和JSON数据处理 10. Socket网络编程 ...20. Web开发相关知识（Servlet、JSP、Spring、Hibernate等）

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值