JAVA基础知识笔记

JAVA基础知识笔记

SIYI171 幻想是一名作家
  2025-03-02 20:08:26 2025-03-02 20:08:26 创建   2025-07-14 06:22:47 2025-07-14 06:22:47 更新      12.5k 字  51 分钟  

这里是一些我个人在学习中整理的笔记，俗话说好记性不如烂笔头。对于我的笔记而言，可能不是很严谨，基于我的理解而写下的，仅供参考。有了好的基础框架，打好地基，才能建成高楼。

什么是JAVA

Java是一门面向对象的编程语言，不仅吸收了C++语言的各种优点，还摒弃了C++里难以理解的多继承、指针等概念，因此Java语言具有功能强大和简单易用两个特征。Java语言作为静态面向对象编程语言的代表，极好地实现了面向对象理论，允许程序员以优雅的思维方式进行复杂的编程。

Java具有简单性、面向对象、分布式、健壮性、安全性、平台独立与可移植性、多线程、动态性等特点。 Java可以编写桌面应用程序、Web应用程序、分布式系统和嵌入式系统应用程序等。

搭建JAVA的开发环境

推荐使用IntelliJ IDEA，eclipse等工具开发

IntelliJ IDEA官网https://www.jetbrains.com/

eclipse官网https://eclipseide.org/

JAVA程序开发运行流程

开发Java程序，需要三个步骤：

编写程序（源代码）→编译程序→运行程序

HelloWorld案例

1
2
3
4
5
6
7
public class HelloWorld{
  //这是我们程序执行的入口
  //main方法
  public static void main(String args){
    System.out.println("HelloWorld");
  }
}

Java中的注释使用说明

注释是指在程序指定的位置添加说明信息，养成写注释的好习惯，让你的代码有更高的可读性，方便二次编写的快速上手

注意：注释不参与运行，仅起到说明的作用

注释的分类

注释案例

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
//这是单行注释的内容

/*
这是多行注释的内容
这是多行注释的内容
这是多行注释的内容
这是多行注释的内容
*/

/**
  *这是文档注释的内容
  *这是文档注释的内容
  *这是文档注释的内容
  *这是文档注释的内容
  */
  
//当然哪一种都可随便使用，看自己的个人喜好

关键字

关键字的概述

文质斌斌：原形容人既文雅又朴实，后形容人文雅有礼貌。同“文质彬彬”。

兴高采烈：叔夜俊侠，故兴高而采烈。兴：兴致。采：精神

关键字：就是Java语言赋予的特定含义单词。

关键字的特点

  • 关键字字母全部都是小写
  • 常用的代码编辑器，IDEA 针对关键字有特殊的颜色标记，非常直观。比如notepad++针对关键字有特殊的颜色标记
  • 常用关键字：public、class、static、void

常量

常量的概念

java常量就是在程序中固定不变的值，是不能改变的数据。

常量类型 说明 举例
字符串常量 用双引号括起来的内容 “你好世界”,”世界你好”
整数常量 不带小数点的数字 888,6666,999
小数常量 带小数的数字 26.66,13.14
字符常量 用单引号 ‘ ‘ 括起来的内容 ‘男’,’女’
布尔常量 布尔值，表示真假 只有两个值：true（真）false（假）
空常量 一个特殊的值，空值 值是：null

输出常量值案例

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
public static void main(String[]args){
  System.out.println("---------字符串常量---------");
  System.out.println（"你好世界，世界你好"）;
  System.out.println("---------整数常量---------");
  System.out.println(666);
  System.out.println(888);
  System.out.println(555);
  System.out.println("---------小数常量---------");
  System.out.println(3.125);
  System.out.println(66.66);
  System.out.println("---------字符常量---------");
  System.out.println('男');
  System.out.println('女');
  System.out.println("---------布尔常量---------");
  System.out.println(true);
  System.out.println(false);
  System.out.println("---------空常量,是不能输出的---------");
  //System.out.println(null);
}

数值类型

Java语言是强类型语言，对于每一个数据都给出了明确的数据类型，不同的数据类型也分配了不同的内存空间，所以他们用来表达的数据大小也是不一样的。

byte类型：1个字节

boolean类型：1个字节

short类型：2个字节

char类型：2个字节

int类型：默认4个字节

float类型：4个字节

long，double类型：8个字节

定义long类型时，需要在后面加L

定义float类型时，需要在后面加F

PixPin_2025-03-02_14-44-35-1024x360

变量

变量的概述

在程序运行过程中，其值可以发生改变的值，变量的值存放在内存条中。

变量的组成

变量的数据类型 变量名称=200

相关例子

1
2
3
4
5
6
7
public static void main(String[]args){
 //定义变量  变量数据类型  变量名称=(赋值)
  int m=200;
  System.out.println(m);
  int m=300;
  System.out.println(m);
}

常见的定义变量错误1

1
2
3
4
5
6
7
8
9
public static void main(String[]args){
 //定义变量  变量数据类型  变量名称=(赋值)
  byte b=1;
  System.out.println(b);
  boolean b=true;
  System.out.println(b);
  //变量b已经被定义为byte类型，再次定义成boolean将会编译报错
  //将boolean类型的变量名更改为b2
}

常见的定义变量错误2

1
2
3
4
5
6
public static void main(String[]args){
  long l;
  System.out.println(l);
  //为赋值的变量不能够使用
  //给long的变量赋值为1，long l=1;
}

常见的定义变量错误3

1
2
3
4
5
6
7
8
public static void main(String[]args){
  float f=3.145;
  System.out.println(f);
  //编译将会报错
  //3.145为double类型，无法以float形式输出
  //应改正为float f=3.145f
  //在double类型后加f表示float类型
}

标识符

标识符的概述

就是给类，方法，变量等起名字的符号。

标识符定义规则(硬性要求)

  • 标识符可以包含 英文字母26个(区分大小写)，0-9数字，$(美元符号)和__(下划线)
  • 标识符不能以数字开头
  • 标识符不能是关键字

标识符定义规则(软性要求)

  • 类名规范：首字母大写，后面每个单词首字母大写(大驼峰式)
  • 方法名规范：首字母小写，后面每个单词首字母大写(小驼峰式)

类型转换

自动类型转换

把一个表示数据范围小的数值或者变量赋值给另一个表示数据范围大的变量。例如：double a=10;

相关例子

1
2
3
4
5
6
7
public static void main(String[]args){
  //演示自动类型转换  整数10  int内存中4个字节
  double d=10;
  System.out.println(d);
  int i=b;
  System.out.println(d);
}

强制类型转换

把一个表示数据范围大的数值或者变量赋值给另一个表示数据范围小的变量。

格式：目标数据类型 变量名=(目标数据类型)值或者变量。

范例：int j = (int) 99.99;

例如：低类型(短字节)可以转换为高类型(长字节)；int型转换成double型，char型转换成int型等等。

相关例子

1
2
3
4
5
public static void main(String[]args){
  //演示强制类型转换将double类型强制类型转换int类型
  int j=(int) 99.99;
  System.out.println(i);
}

表示数值范围从小到大

PixPin_2025-03-02_19-08-34-1024x367

算术运算符

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

表达式：用运算符把常量或者变量连接起来符号

如： int a=0;

int b=1;

int c=a+b;

+:是运算符，并且是算术运算符

a+b：是表达式，由于+是算术运算符，所以这个表达式叫算术表达式。

符号 说明 举例
+ 加 加法
– 减 减法
* 乘 乘法
/ 除 除法
% 取余 得到两个数做除法的余数

相关例子

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
public static void main(String[]args){
  int a=8;
  int b=5;
  System.out.println("a/b=");
  System.out.println(8.0/b); // 88/5==1.6
  System.out.println("a*b=:");
  System.out.println(a*b); // 8*5==40
  System.out.println("a-b=:");
  System.out.println(a-b); // 8-5==3
  System.out.println("a+b=:");
  System.out.println(a+b); // 8+5==13
  System.out.println("a%b=:"); // 8/5==1.6
  System.out.println(a%b); // 8%5==3
  System.out.println(a%b); // 8%5==3
  //两个数都是为整数计算结果就是整数 不会带上小数点
}

字符的“+”操作

拿字符在计算机底层对应的数值来进行计算的

‘A’→ 65 A-Z是连续的

‘a’→ 97 a-z是连续的

算术表达式中包含多个基本数据类型的值的时候，整个算术表达式的类型会自动进行提升

提升规则：

byte类型，short类型和char类型将被提升到int类型

整个表达式的类型自动提升到表达式中最高等级操作数同样的类型

等级顺序：byte,short,char->int->long->float->double

底层计算使用ASCII

相关例子

1
2
3
4
5
6
7
8
9
10
11
12
public static void main(String[] args){
  int a=20;
  char c='A';//'a'底层数值类型值=97'A'底层数值类型值=65
  System.out.println(a+c) ;
  short s=20;
  byte b=l;
  //c=66+s=20+b=1==87
  int j=c+s+b;
  System.out.println(j);
  doub1e j2=89.99+s+c;
  System.out.println(j2);
}

当“+”操作中出现字符串时，这个”+”是字符串连接符，而不是算术运算。

案例：

在”+”操作中，如果出现了字符串，就是连接运算符，否则就是算术运算。当连续进行“+”操作时，从左到右逐个执行。

1
2
3
4
5
6
//定义变量维码
int i =10;
System.out.println("siyi:"+i) ;
System. out.println(1+i) ;
System. out. println(1+i+"siyi"+3+4) ;
System. out. println(1+i+"siyi"+(3+4)) ;

增自减运算符

符号 说明 举例
++ 自增 变量的值+1
– 自减 变量的值-1

注意事项:

  • ++和–既可以放在变量的后边，也可以放在变量的前边。
  • 单独使用的时候，++和-－无论是放在变量的前边还是后边，结果是一样的。
  • 参与操作的时候，如果放在变量的后边，先拿变量参与操作，后拿变量做++或者－-。
  • 参与操作的时候，如果放在变量的前边，先拿变量做++或者－-，后拿变量参与操作。
  • 最常见的用法：单独使用。

相关例子

1
2
3
4
5
6
7
8
9
public static voidd main(String[]args){
  int i=10;
  // int sum=i+l;
  // i++;
  // int i=i(l0)+l
  //i++ 先将原来i的值=10 赋值给我们的j=10;在来对我们i做+1的操作赋值给i=10+1=11;8
  int j=++i;
  System.out.println("j:"+j);
}

关系运算符

关系运算符有6种关系，分别为小于、小于等于、大于、等于、大于等于、不等于。

符号 说明
== a==b，判断a和b的值是否相等，成立为true，不成立为false
!= a!=b，判断a和b的值是否不相等，成立为true，不成立为false
> a>b，判断a是否大于b，成立为true，不成立为false
>= a>=b，判断a是否大于等于b，成立为true，不成立为false
< a<b，判断a是否小于b，成立为true，不成立为false
<= a<=b，判断a是否小于等于b，成立为true，不成立为false

注意事项：关系运算符的结果都是boolean类型，要么是true，要么是false。

逻辑运算符

逻辑运算符把各个运算的关系表达式连接起来组成一个复杂的逻辑表达式，以判断程序中的表达式是否成立，判断的结果是 true 或 false。

在数学中，一个数据x，大于3，小于6，我们可以这样来进行表示：3<x<6。在Java中，需要把上面的式子先进行拆解，再进行合并表达。

拆解为：x>3和x<6

合并为：x>3&&x<6

&&其实就是一个逻辑运算符。我们可以这样说，逻辑运算符，是用来连接关系表达式的运算符。

当然，逻辑运算符也可以直接连接布尔类型的常量或者变量。

符号 说明 举例
& 逻辑与 a&b，a和b都是true，结果就为true，否则为false
| 逻辑或 a| b，a和b都是false，结果为false，否则为true
^ 逻辑异或 a^b，a和b结果不同为true，相同为false
! 逻辑非 !a，结果和a的结果正好相反

短路逻辑运算符

只要有一个表达式的值为false，那么结果就可以判定为false了，没有必要将所有表达式的值都计算出来，短路与操作就有这样的效果，可以提高效率。同理在逻辑或运算中，一旦发现值为true，右边的表达式将不再参与运算。

逻辑与&，无论左边真假，右边都要执行。

短路与&&，如果左边为真，右边执行；如果左边为假，右边不执行。

逻辑或，无论左边真假，右边都要执行。

短路或，如果左边为假，右边执行；如果左边为真，右边不执行。

3>6&&4<10

3>6 false

符号 说明 举例
&& 短路与 作用和&相同，但是又短路效果
|| 短路或 作用和|相同，但是有短路效果

三元运算符

三元运算符语法格式

关系表达式？表达式1：表达式2

解释：问号前面的位置是判断的条件，判断结果为boolean型，为true时调用表达式1,为false时调用表达式2。其逻辑为：如果条件表达式成立或者满足则执行表达式1，否则执行第二个。

1
2
3
4
int a = 10;
int b = 20;
int c = a > b ？ a：b；
// 判断 a>b 是否为真，如果为真取a的值，如果为假，取b的值

案例1

需求：动物园里有两只老虎，已知两只老虎的体重分别为180kg、200kg，请用程序实现判断两只老虎的体重是否相同。

1
2
3
4
int weight1 = 180;
int weight2 = 200;
boolean b = welght1== weight27 ? true :  false;
System. out. println("b:" + b) ;

案例2

在我们班级中有三名同学，已知他们的身高分别为150cm、210cm、165cm，请用程序实现获取这三名同学的最高身高。

1
2
3
4
5
6
int height1 = 150;
int height2 = 210;
int height3 = 165;
int tempHeight = height1 > height2 ? height1 : height2;
int maxHeight = tempHeight > height3 ? tempHeight : height3;
System. out. println("maxHeight:" + maxHeight) ;

Scanner打印机用法

Sanner使用基本步骤

①导包import java.util.Scanner;

导包的动作必须出现在定义的类上面

②创建对象

Scanner sc=new Scanner(System.in) ;

sc是为变量的名称 可以发生变化 其他的都不允许发生变化

③接受数据

int i=sc.nextInt();/／ 接受一个int数据

i是为变量的名称可以发生变化其他的都不允许发生变

相关例子

1
2
3
4
5
6
7
8
9
10
11
import java.util.Scanner;
public class Demo{
  public static void main(String[]args){
    //创建了一个打印机
    Scanner sc= new Scanner(System.in);
    System.out.println("请您输入一个数值类型的数据");
   // 接受用户在控制台中输入int类型
    int i=sc.nextInt();
    System.out.println（"您输入的数值类型值为:"+i）;
  }
}

Scanner类实现求两个数之和

1
2
3
4
5
6
Scanner sc= new Scanner(System.in) ;
System.out.println（"请输入第一个数"）；
int a=sc.nextInt() ;
System.out.println（"请输入第二个数"）;
int b=sc.nextInt();
System.out.println（"两个数计算结果:"+(a+b));

流程控制语句

  • 顺序结构
  • 分支结构(if,Switch)
  • 循环结构(for, while, do… while)

判断语句1－if写法1

1
2
3
if(关系表达式）{
  语句体;
}
  1. 首先判断关系表达式看其结果是true还是false
  2. 如果是 true就执行语句体
  3. 如果是 false就不执行语句体

案例

1.判断a和b的值是否相等，如果相等，就控制台输出a等于b

2.判断a和b的值是否相等，如果不相等，就控制台输出a不等于b

1
2
3
4
5
6
7
8
int a=20;
int b=20;
if(a==b) {
  System.out.println("a等于b");
}
if(a!=b) {
  System.out.println("a不等于b"）;
}

判断语句1－if写法2

1
2
3
4
5
if (关系表达式){
  语句体1;
}else {
  语句体2;
}
  1. 首先判断关系表达式看其结果是true还是false
  2. 如果是true就执行语句体1;
  3. 如果是false就执行语句体2。

案例

定义两个整数类型变量，判断a是否大于b，如果a大于b，则控制台输出a的值大于b，如果a不是大于b 则控制台输出a的值不大于b

1
2
3
4
5
6
7
int a=20;
int b=30;
if(a>b) {
  System.out.println("a的值大于b");
}else{
   System.out.println("a的值不大于b");
}

判断语句1－ if案例 奇偶数

需求：任意给出一个整数，请用程序实现判断该整数是奇数还是偶数，并在控制台输出该整数是奇数还是偶然数

分析思路

  1. 键盘录入数据
  2. 判断该录入的键盘数是奇数还是偶数
  3. 如何判断一个数是偶数还是奇数?

number%2 如果余数为0则是为偶数 如果有余数则是为奇数

相关案例

1
2
3
4
5
6
7
8
Scanner sc= new Scanner(System.in) ;
System.out.println("请输入一个数值类型的值");
int a=sc.nextInt();
if(a2==0){
  System.out.println("a+该数是为偶数");
}else{
  System.out.println("a+"该数是为奇数");
}

多重if判断语句

1
2
3
4
5
6
7
8
9
10
11
if (判断条件1）{
  执行语句1;
}else if(判断条件2){
  执行语句2;
}
...
}else if (判断条件n){
  执行语句n;
}else{
  执行语句n+1;
}

首先判断关系表达式1看其结果是true还是false

如果是true就执行语句体1

如果是false就继续判断关系表达式2看其结果是true还是false

如果是true就执行语句体2

如果是false就继续判断关系表达式…看其结果是true还是false

…

如果没有任何关系表达式为true，就执行语句体n+1。

案例1

需求：键盘录入一个星期数{1,2,3,4,5,6,7}输出对应的星期一….星期日

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
//创建键盘录入数据
Scanner sc= new Scanner(System.in);
System.out.println("请输入星期数:")；
//获取到键盘录入的数据
int week=sc.nextInt();
if(week==1){
  System.out.println("星期一")；
}else if(week==2){
  System.out.println("星期二");
}
...
else if(week==7){
  System.out.println("星期日");
}else{
  System.out.println（"您输入的星期数有问题..")；
}

案例2

需求：现在需要根据学生的成绩评定出等级，90分以上的是优，80-90分的是良，70-79是中，60-69是及格，60分以下是不及格

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
// 创建键盘录入数据
Scanner sc= new Scanner(System.in);
System.out.println("请输入成绩:");
// 获取到键盘录入的数据
int result=sc.nextlnt();
if(result>90&&result<=100){
  System.out.println("成绩为优秀");
}else if(result>=80&&result<=90){
  System.out.println("成绩为良");
}else if(result>=70&&result<80){
  System.out.println("成绩为中等");
}else if(result>=60&&result<70){
  System.out.println("成绩为及格");
}else {
  System.out.println("成绩为不及格");
}

switch语句的用法

1
2
3
4
5
6
7
8
9
10
11
12
switch(表达式){
    case 值1:
      语句体1;
    break;
    case 值2:
      语句体2;
    break;
    ...
    default:
      语句体n+1;
    break;
}

格式说明

  1. 表达式取值为byte,short,int,char,JDK5以后可以是枚举，JDK7以后可以是字符串(String)
  2. case：后面跟的是要和表达式进行比较的值
  3. 语句体：这个部分可以是一条或者多条语句
  4. break：表示中断，结束的意思，可以控制switch语句的结束
  5. default：当所有的值都和表达式不匹配的时候，就执行default控制的语句。其实他就相当于if语句的else

执行流程

  1. 首先计算出表达式的值
  2. 其次，和case依次比较，一旦有对应的值，就会执行相应的语句，在执行的过程中，遇到break就会结束。
  3. 最后，如果所有的case都和表达式的值不匹配，就会执行default语句体部分，然后程序结束掉。
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
//创建键盘录入数据
Scanner sc= new Scanner(System.in);
System.out.println("请输入星期数:")；
//获取到键盘录入的数据
int week=sc.nextInt();
switch(week){
  case 1:System.out.println("星期—");
  //如果匹配上case 则会 break退出 switch语句
  break;
  case 2:System.out.println("星期二");
  //如果匹配上case 则会 break退出 switch语句
  break;
  ...
  default:
    System.out.println("您输入的星期数不正确!");
  break;
}

switch语句春夏秋冬案例

需求：一年有12个月，分属于春夏秋冬4个季节，键盘录入一个月份，请用程序实现判断该月份属于哪个季节，并输出。

春：3、4、5

夏：6、7、8

秋：9、10、11

冬：1、2、12

多个case后面的值不可以重复，重复则编译报错。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
//创建键盘录入数据
Scanner sc= new Scanner(System.in);
System.out.println("请输入月份:")；
//获取到键盘录入的数据
int month=sc.nextInt();
switch(month){
  case 3:
  case 4:
  case 5:
    System.out.println("春");
  break;
  case 6:
  case 7:
  case 8:
    System.out.println("夏");
  break;
  case 9:
  case 10:
  case 11:
    System.out.println("秋");
  break;
  case 12:
  case 1:
  case 2:
    System.out.println("冬");
  break;
  default:
    System.out.println("您输入的星月数不正确!");
  break;
}

循环语句内容

  • 循环语句1－for
  • 循环语句2－while
  • 循环语句3－do…while
  • 控制跳转语句
  • 嵌套循环

循环结构的组成

初始化语句：用于表达循环开启时的起始状态，简单说就是循环开始时候什么样

条件判断语句：用于表示循环反复执行的条件，简单说就是判断循环是否能一直执行下去

循环体语句：用于表示循环反复执行的内容，简单说就是循环反复执行的事情

条件控制语句：用于表示循环执行中每次变化的内容，简单说就是控制循环是否能执行下去

循环结构对应的语法

初始化语句：这里可以是一条或多条语句，这些语句可以完成一些初始化操作

条件判断语句：这里使用一个结果值为boolean类型的表达式，这个表达式能决定是否执行循环体。例如：a<3

循环体语句：这里可以是任意语句，这些语句将反复执行

条件控制语句：这里通常是使用一条语句来改变变量的值，从而达到控制循环是否继续向下执行的效果。常见的i++，i－这样的操作。

1
2
3
for(初始化语句;条件判断语句;条件控制语句){
  循环体语句;
}

执行流程

  1. 执行初始化语句
  2. 执行条件判断语句，看其结果是true还是false，如果是false，循环结束，如果是true，继续执行
  3. 执行循环体语句
  4. 执行条件控制语句
  5. 回到2过程继续

for循环输出5-1案例

需求：在控制台输出1-5和5-1数据

分析：

  1. 反复进行输出动作，使用循环结构
  2. 从1开始到5结束，设置初始化从i=1开始
  3. 从1开始到5结束，设置条件判断语句i<=5
  4. 从1到5，每次增加设置条件控制每次+1
  5. 循环体中打印对应的数据
1
2
3
for(int i=1;i<=5;i++){
  System. out. println("i"+i);
}

求和的案例

需求：求1-5之间的数据和，并且将求和的结果在控制台输出

分析：

  1. 求和的最终结果必须保存起来，需要定义一个int类型变量sum，用于保存求和的结果，初始值为0
  2. 从1开始到10结束的数据，使用循环结构完成
  3. 将反复进行的事情写入循环结构内部，此处反复进行的事情是将数据i加到用于保存最终求和的变量sum中
  4. 当循环执行完毕时，将最终数据打印出来
1
2
3
4
5
6
7
8
System.out.println("求1-5的总和");
int sum=0;
for(int i=1;i<=5;i++){
  //sum=sum+i;
  sum+=i;
  //sum+=i；==等价于sum=sum+i;
}
System.out.println("sum:"+sum);

求和偶数和

需求：求1-100之间的偶数和，并将求和结果在控制台输出

  1. 对1-100的数据求和与1-5的数据求和几乎完全一样，仅仅是结束条件不同
  2. 对1-100的偶数求和，需要对求和操作添加限制条件
  3. 限制条件是偶数才参与运算，因此条件应该是判断是否是偶数
  4. 当循环执行完毕时，将最终数据打印出来
1
2
3
4
5
6
7
8
9
10
int sum=0;
for(int i =1;i<=100;i++){

  if(i%2==0){//执行的限制条件

  sum+=i;

  }

}

水仙花

需求：在控制台输出所有的”水仙花数”

什么是水仙花数就是三位数，但是不是全部的三位数都是水仙花数。

100-999 之间

水仙花数的个位的立方+十位的立方+百位的立方=这个水仙花数

例如：

100的个位0 十位0 百位1 =0_0_0+0_0_0+1_1_1=1 不是水仙花数

371的个位7 十位1 百位3 =3_3_3+7_7_7+1_1_1=371 是水仙花数

三位数的个位数如何求：

371%10=1;

三位数的十位数如何求：

1.371通过除以10得到结果=37 371/10=37

2.37通过对10取余可以得到余数为7 37%10=7

3.综合371/10%10=7；

三位数的百位数如何求：

371/100=3;

1
2
3
4
5
6
7
for(int i =100;i<=999;i++){
  int ge=i%10;
  int shi=i/10%10;
  int bai=i/100;
  if((ge*ge*ge+shi*shi*shi+bai*baibai)==i){
   System.out.println("水仙花数："+i); 
  }

珠穆朗玛峰案例

需求：世界上最高山峰是珠穆朗玛峰（8848.43米=884830毫米），假如我有一张足够大的纸，它的厚度是0.1毫米，请问，我折叠多少次，可以折叠成珠穆朗玛峰的高度？

提示：纸张折叠一次后厚度是以前的两倍

（1）因为要反复折叠，所以要使用循环，但是不知道折叠多少次，这种情况下更适合使用while循环

（2）循环的执行过程中每次纸张折叠，纸张的厚度需要加倍，因此需要事先定义纸张厚度，在循环中使厚度加倍

（3）折叠的过程中当纸张厚度大于珠峰就停止了，因此继续执行的要求是纸张厚度小于珠峰高度

（4）设置一个计数器，在循环中执行累加，对应折叠了多少次

1
2
3
4
5
6
7
8
9
10
11
//折叠次数
int count=0;
//珠穆朗玛峰高度(毫米)
int zf=8848430;
//纸张厚度
double page=0.1;
while(page<=zf){
  page*=2;
  count++;
}
System.out.println("需要折叠"+count+"次");

do while循环语句

1
2
3
4
5
6
7
8
9
10
完整格式：
初始化语句;

do{

  循环体语句;

  条件控制语句;

  }while(条件判断语句);（注意do..while语句是以;结束语句与其他循环语句不同）

执行流程：

①执行初始化语句

②执行循环体语句

③执行条件控制语句

④执行条件判断语句，看其结果是true还是false

如果是false，循环结束

如果是true，继续执行

③回到②继续

死循环

1
2
3
4
5
6
7
8
9
10
//for死循环写法：
for(;;){
}
//while死循环写法：
while(true){
}
//do while死循环写法：
do{
}while(true);
//注意：死循环后可能会非常消耗cpu的资源可能会引发导致cpu飙高100%

三种不同循环语句区别

for循环适合针对一个范围判断进行操作，即已知循环次数。while循环适合判断次数不明确的操作，切循环结束后依旧可以使用。

for、while循环都必须先判断条件是否成立，然后决定是否执行循环体。

do…while循环比较特殊，它先执行循环体，然后根据判断条件决定是否再次执行循环，即do…while至少执行一次循环。

跳转控制语句

跳转控制语句(break),跳出循环，结束循环

跳转控制语句(continue),跳过本次循环，继续下次循环

注意：continue只能在循环中进行使用！

continue用法：使用for循环1-10不输出偶数结果

1
2
3
4
5
6
for(int i=1;i<10;i++){
  if(i%2==0){
    continue;//结束本次循环
  }
  System.out.println("i:"+i);
}

循环嵌套

循环嵌套的需求：

在控制台输出一天的小时和分钟，分钟和小时的范围：

公式：

分钟：0<=minute<60

小时：0<=hour<24

1
2
3
4
5
6
for(int hour=0;hour<=24;hour++){
  for(int minute;minute<=60;minute++){
    System.out.println(hour+"时"+minute+"分");
  }
  System.out.println("--------------------");
}

Random随机数

作用：用于产生一个随机数

1：导包

import java.util.Random;

导包的动作必须出现在类的定义上边

2：创建对象

Random r=new Random();

上边这个格式里面，r是变量名，可以变，其他的都不允许变

3：获取随机数

int number =r.nextInt(10);//获取数据的范围：[0.10)包括0，不包括10

上边这个格式里面，number是变量名，可以变，数字10可以变，其他的都不可以变

猜数字游戏

1.实现控制台的猜数字游戏。游戏运行时产生一个1～100之间的随机数字

2.要求用户从控制台输入数字，若输入的数字比随机数小，则输出“太小了，再大一点！”；若输入的数字比随机数大，则输出“太大了，再小一点！”，若输入的数字与随机数相同，则输出“恭喜你猜对了！”。游戏过程中用户需要多次输入所猜数字，直到猜中为止。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
import java.util.Random;
import java.util.Scanner;
  public static void main(String[] args){
    Random rd=new Random();
    int number1=rd.nextInt(100)+1;
    while(true){
      System.out.println("请您输入一个数字");
      Scanner sc=new Scanner(System.in);
      int number2=sc.nextInt();
      if(number2>number1){
        System.out.prinln("您输入的数字大于随机数");
      }else if(number2<number1){
        System.out.prinln("您输入的数字小于随机数");
      }else{
        System.out.prinln("恭喜您猜对了");
        break;
      }
    }
  }

数组概述

在一个班级中，有非常多学生需要存储每位学生的考试成绩.

比如a=98;b=97;c=96;d=88;…

1）数组概述：一次性声明大量的用于存储数据的变量;

这些要存储的数据通常都是相同类型数据。例如：全班同学的考试成绩。

2）数组：是一种用于存储多个相同类型数据的存储模型

数组定义格式

范例1：推荐使用

定义格式1:数据类型变量名

int[] arr;

//含义：定义了一个int类型的数组，数组名是arr;

范例2:

数据类型变量名[]

int arr [];

//含义：定义了一个int类型的变量，变量名是arr数组；

数组动态初始化

1.数组初始化概述：Java中的数组必须先初始化，然后才能使用；初始化就是为数组中的数组元素分配内存空间，并为每个数组元素赋值。

2.数组初始化方式：动态初始化、静态初始化

3.动态初始化：初始化时只指定数组长度，有系统为数组分配初始值

4.动态初始化格式:

数据类型[] 变量名 = new 数据类型[数组长度];

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
//数据类型[]变量名=new数据类型[数组长度]；
int[] array = new int[3];
/*
*
*int[] array =new int[3];
*左边int[]array
*int数组中的元素是为int数据类型
*[]定义数组
*array数组的变量名称
*=
*new给数组分配内存空间
*int数组中的元素是为int数据类型
*[3]3数组的长度[数组的长度]
*右边new int[3];
*/

数组元素的访问

1）数组变量的访问方式：数组名

2）数组内部保存的数据的访问方式：数组名[索引]//编号从0开始

3）索引：索引是数组中数据的编号方式，作用就是用于访问数组中的数据，数组名[索引等同于变量名是一种特殊的变量名；索引从0开始，是连续的，逐一增加，每次加一

4） 例子： System.out.println(arr[O]); //访问数组的第一个元素

1）数组变量的访问方式：数组名

2）数组内部保存的数据的访问方式：数组名[索引]//编号从0开始

3）索引：索引是数组中数据的编号方式，作用就是用于访问数组中的数据，数组名[索引等同于变量名是一种特殊的变量名；索引从0开始，是连续的，逐一增加，每次加一

4） 例子： System.out.println(arr[O]); //访问数组的第一个元素

数组内存分配

Java程序在运行时，需要在内存中分配空间，为了提高运算效率，有对空间进行了不同区域的划分，因为每一片区域都有特定的处理数据方式和内存管理方式

JDK内存空间分为：堆、栈、方法区、本地方法栈等。

shuzuneucunfebpei1

shuzuneucunfebpei2-1024x469

PixPin_2025-03-13_18-53-25-1024x437

数组静态初始化

静态初始化：初始化时指定每个数组元素的初始值，由系统决定数组长度
格式：数据类型[] 数组名 = new 数据类型[]{元素1,元素2,元素3,..};
举例: int[] arr = new int[]{1,2,3};

简化格式：数据类型[] 数组名 ={元素1,元素2,元素3,..];
int[] arr = {1,2,3};

1
2
3
4
5
6
7
8
//静态初始化数组
int[] arr = new int[]{1,2,3};
//精简写法
int[] arr = {1,2,3};
System.out.println(arr);
System.out.println(arr[0]);
System.out.println(arr[1]);
System.out.println(arr[2]);

数组的常见问题

ArraylndexOutOfBoundsException:数组索引I越界异常
原因：你访问了不存在的索引。

NullPointerException:空指针异常
原因：数组已经不在指向堆内存了。而你还用数组名去访问元素。

数组的遍历

格式:数组名称.length(数组长度)
案例:arr.length

1
2
3
4
5
6
7
8
9
10
11
12
13
int[] arr = {66,88,99,10}
System.out.println(arr[0]);
System.out.println(arr[1]);
System.out.println(arr[2]);
System.out.println(arr[3]);

for(int i=0;i<4;i++){
  System.out.println(arr[i]);
}

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

数组获取最大值

1
2
3
4
5
6
7
8
9
10
11
12
//1.定义一个数组存放数字
int[] arr={151,158,170,162,131,168,126};
//临时保存的最大值
int max=arr[0];//临时最大值151
for(int i=1;i<arr.length;i++){
  if(arr[i]>max){
    //修改临时保存的max值
    max=arr[i];
  }
}
//输出最大值
System.out.println("数组中最大的值："+max);

方法的概述

方法(method)是将具有独立功能的代码块组织成为一个整体，使其具有特殊功能的代码集

1.方法必须先创建才可以使用，该过程成为方法定义
2.方法创建后并不是直接可以运行的，需要手动使用后才执行，该过程成为方法调

1
2
3
4
5
6
7
8
9
10
public static void main(String[] args){
  max(10,20);
}

public static void max(int a,int b){
  //获取两个数中的最大值
  int max=a>b?a:b;
  //输出最大值
  System.out.println(max);
}

方法定义与调用

定义方法
格式：
public static void 方法名 () {
//方法体；
}
范例：
public static void siyi () {
//方法体；
}
方法调用：
格式：方法名称();
范例：siyi();

注意：方法必须先定义后才可以调用，否则程序将会报错

案例

需求：定义一个方法判断两个数谁最大

1
2
3
4
5
6
7
8
public static void getMax(){
  int a = 10;
  int b = 20;
  //获取两个数中的最大值
  int max = a > b ? a : b;
  //输出最大值
  System.out.println(max);
}

常见的错误
1.在定义方法的过程中，不能够将方法定义在方法的里面

带参数方法的定义和调用

带参数的定义
格式：public static void 方法名(参数){…}

格式：单个参数：public static void 方法名(数据类型 变量名称){…}
范例：单个参数： public static void 方法名(int a){…}

格式：多个参数：public static void 方法名(数据类型 变量名称,数据类型 变量名称,…){…}
范例：多个参数：public static void 方法名(int a,int b){…}

注意事项：
1.方法定义时，参数中的数据类型与变量名都不能缺少，缺少任意一个程序将报错
2.多个参数之间使用逗号(,)分割

带参数的方法调用
格式：public static void getMax(int a,int b){…}
带参数方法调用格式：方法名(参数)：
单个参数：方法名(变量名/常量值)；例如getNumber(20)
多个参数：方法名(变量名1/常量值1,变量名2/常量值2)；例如getMax(10,20)
方法调用时，参数的数量与类型必须与方法定义中的设置相匹配，否则程序将报错

形参和实参

形参：方法定义中的参数
等同于变量定义格式，例如：int a;
实参：方法调用中的参数
等同于使用变量或常量，例如：10, a, b

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

带返回值方法定义格式：

1
2
3
4
5
6
7
public static 数据类型 方法名 (参数){
  return 数据;
}
范例：
public static int getMax(int a){
  return a;
}

注意事项：
方法定义时return后面的返回值与方法定义上的数据类型要匹配，否则程序将报错

方法的定义注意事项

1.方法不能嵌套定义：方法是平级关系，不能嵌套定义
2.void表示无返回值，可以省略return，也可以单独的书写return，后面不加数据

方法的通用格式

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

1.public static 修饰符
2.void返回值类型，方法操作完毕之后返回的数据的数据类型；如果方法操作完毕，没有数据返回，这里写void，而且方法体中一般不写return
3.方法名调用方法时候使用的标识
4.参数数据类型和变量名组成，多个参数之间用用逗号隔开
5.方法体完成功能的代码块
6.return 如果方法操作完毕，有数据返回，用于把数据返回给调用者
定义方法时，明确方法操作完毕之后是否有数据返回，如果没有，写void；如果有，写对应的数据类型;
明确参数的类型和数量

方法的重载

方法重载指同一个类中定义的多个方法之间的关系，满足下列条件的多个方法相互构成重载
1.多个方法在同一个类中
2.多个方法具有相同的方法名
3.多个方法的参数类型不相同，类型不同或者数量不同

1
2
3
4
5
6
7
public static void sum(int a){

}

public static void sum(int a,int b){

}

方法重载的特点:
1.重载仅对应方法的定义，与方法的调用无关，调用方法参照标准格式
2.重载仅针对同一个类中的名称与参数进行识别，与返回值类型无关，换句话说不能通过返回值类型来
判断两个方法是否相互重载。

需求1：求两个int类型数据的和的方法
需求2：求两个double类型数据和的方法
需求3：求三个int类型数据和的方法

1
2
3
4
5
6
7
8
9
10
public static int sum(int a,int b){
  return a+b;
}

public static double sum(double a,double b){
  return a+b;
}
public static int sum(int a,int b,int c){
  return a+b+c;
}

方法的参数传递基本类型

对于基本数据类型的参数，形参的改变，不会影响到实参数的值

1
2
3
4
5
6
7
8
9
10
11
12
public static void main(String[] args){
  int number = 10;
  System.out.println("主方法调用change方法前number（实参）："+number);//number=10
  change(number);//方法修改number10改为20
  System.out.println("主方法调用change方法后number（实参）："+number);//number=10
}

public static void change(int number){
  System.out.println("change中number(形参)："+number);//number=10
  number = 20;
  System.out.println("change中number(形参)："+number);//number=20
}

方法的参数传递引用类型

对于引用类型的参数，形参的改变，会影响到实参数的值

1
2
3
4
5
6
7
8
9
10
public static void main(String[] args){
  int[] arr = {30,60,90};
  System.out.println("调用change方法前："+arr[0]);//arr=30
  change(arr);//方法修改number10改为20
  System.out.println("调用change方法后："+arr[0]);//arr=100
}

public static void change(int[] arr){
  arr[0] = 100;//arr[0]=30 改成=100
}

案例：数组的遍历

需求：设计一个方法用于数组遍历，要求遍历的结果是在一行上，例如[22,33,44,55,66,77]
System.out.println(“内容”）;输出内容并换行
System.out.print(“内容”）;输出内容不换行
System. out. println（）;起到换行的作用

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
public static void main(String[] args){
  int[] arr={22,33,66,77,88,99};
  arr(arr);
}

public static void arr(int[] arr){
  if(arr==null){
    return;//如果传递的是一个空数组的话，后面的代码不会继续执行的
  }
  for(int i=0;i<arr.length;i++){
    System.out.print(arr[i]);
    //arr.length-1=6-1=5  0,1,2,3,4
    if(i<arr.length-1){
      System.out.print(",")
    }
  }
}

案例：数组的最大值

需求：设计一个方法用于获取数组中元素最大值，调用该方法并且输出结果

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
public static void main(String[] args){
  int[] arr={10,5,1,100,200};
  int max = getMax(arr);
  System.out.println("定义方法查找数组中的最大值："+max);
}

//1.需要定义方法   需要查找到数组中的最大值
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;
}

案例：逢七过

java朋友聚会的时候可能会玩一个游戏：逢七过，规则是：从任意一个数字开始报数，
当你要报的数字包含7或者是7的倍数时都要说：过

题目需求:
从任意一个数字开始报数，当你要报的数字包含7或者是7的倍数时都要说：过。

1:数据在1-100之间，用for循环实现数据的获取
2:根据规则，用if语句实现数据的判断：要么个位是7，要么十位是7，要么能够被7整除
解析: x%10==7 x/10%10==7 x%7==0
3:在控制台输出满足规则的数据

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
public class test {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        int number = sc.nextInt();
        visiteSeven(number);
    }
    public static void visiteSeven(int number) {
        if (number>1 && number<100) {
            for (int i = 1; i <= number; i++) {
                if (i % 7 == 0  i % 10 == 7  i / 10 == 7) {
                    System.out.println(i);
                }
            }
        }
        else {
            System.out.println("输入的数字不在1-100之间");
        }
    }
}

案例：数组元素求和

需求：有这样的一个数组，元素是{71,27,33,22,100,87,77,57}。 求出该数组中满足要求
的元素和。
要求是：求和的元素个位和十位都不能是7，并且只能是偶数
1.定义一个数组，用静态初始化完成数组元素的初始化;
2.定义一个求和变量，初始值是0;
3.遍历数组，获取到数组中的每一个元素;
4.判断该元素是否满足条件，如果满足条件就累加
arr[x]%10!=7 arr[x]/10%10!=7 arr[x]%2= =0
5.输出求和变量的值。

1
2
3
4
5
6
7
8
9
10
public static void main(String[] args) {
    int[] arr ={71,27,33,22,100,87,77,57};
    int sum = 0;
    for (int i = 0; i < arr.length; i++) {
        if (arr[i]%10!=7 && arr[i]/10%10!=7 && arr[i]%2==0){
            sum += arr[i];
        }
    }
    System.out.println("sum = " + sum);
}

案例：比较两个int类型数组是否相同

定义一个方法，用于比较两个int数组的数字是否相同
分析:
1、定义方法:
方法的返回值为boolean类型
参数为两个数组(int[]arrl,int []arr2)
2、比较数组长度是否一样；
3、使用for循环比较数组内容

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
public static void main(String[] args) {
    int[] a = {1,2,3,4,5};
    int[] b = {1,2,3,4,5};
    System.out.println(compare(a,b));
}
public static boolean compare(int[] a,int[] b) {
    if(a.length != b.length) {
        return false;
    }
    for(int i = 0;i < a.length;i++) {
        if(a[i] != b[i]) {
            return false;
        }
    }
    return true;
}

案例：查找该元素对应数组中的index位置

已知一个数组 arr = {29, 68, 33, 44,10};键盘录入一个数据，查找该数据在数组中的索引l。 并在控制台
输出找到的索引值。如果没有查找到，则输出-1

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
public static void main(String[] args) {
    int[] arr = {29,68,33,44,10};
    Scanner sc = new Scanner(System.in);
    System.out.println("请输入一个整数：");
    int num = sc.nextInt();
    int index = -1;
    for (int i = 0; i < arr.length; i++) {
        if (arr[i] == num) {
            index = i;
            break;
        }
    }
    if (index == -1) {
        System.out.println("数组中没有这个元素");
    } else {
        System.out.println("数组中有这个元素，下标为：" + index);
    }
}

案例：评委打分

在编程竞赛中，有6个评委为参赛选手打分，分数为0-100的整数分。选手的最后得分为：去掉一个最高
分和一个最低分的4个评委平均值＊请写代码实现 (不考虑小数部分)

分析：
A:定义一个长度为6的数组
B:键盘录入评委的分数并且存入到数组中
C.写方法实现获取最高分getMax，最低分getMin
D:写方法求评委的分数和 sum
E:平均分：(和-最高分-最低分)/(arr.length-2)
F:输出平均分avg

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
public static void main(String[] args) {
    int[] arr = new int[6];
    Scanner sc = new Scanner(System.in);
    for (int i = 0; i < 6; i++) {
        arr[i] = sc.nextInt();
    }
    System.out.println("Max: " + getMax(arr));
    System.out.println("Min: " + getMin(arr));
    System.out.println("Sum: " + getSum(arr));
    System.out.println("Avg: " + getAvg(arr));
}
public static int getMax(int[] arr) {
    int max = arr[0];
    for (int i = 1; i < 6; i++) {
        if (arr[i] > max) {
            max = arr[i];
        }
    }
    return max;
}
public static int getMin(int[] arr) {
    int min = arr[0];
    for (int i = 1; i < 6; i++) {
        if (arr[i] < min) {
            min = arr[i];
        }
    }
    return min;
}
public static int getSum(int[] arr) {
    int sum = 0;
    for (int i = 0; i < 6; i++) {
        sum += arr[i];
    }
    return sum;
}
public static double getAvg(int[] arr) {
    return getSum(arr)-getMax(arr)-getMin(arr) / (arr.length - 2);
}

案例：反转数组

需求：已知一个数组arr={29,68,33,44,10);用程序实现把数组中的元素值交换
交换后的数组arr={10,44,33,68,29};并在控制台输出交换后的数组元素

1
2
3
4
5
6
int[] arr = {33, 22, 66, 85, 55, 16, 88];
for (int start = 0, end = arr.length - 1; start < = end; start++, end--) {
  int temp = arr[start];
  arr[start] = arr[end];
  arr[end] = temp;
}

结语

恭喜你！走到这一步，意味着你已经成功跨过了Java编程的入门门槛，掌握了这门强大工具的基础知识。然而，这仅仅是编程世界的起点，远未到达终点。Java作为一门广泛应用的编程语言，其深度和广度远超初学者的想象。你现在所掌握的，或许只是冰山一角，真正的挑战和精彩还在前方等待着你。

接下来，你将进入一个更为抽象和复杂的领域。编程不仅仅是学习语法和编写代码，更是一种思维方式的训练。你将面对数据结构、算法设计、设计模式、并发编程、内存管理等高级主题。这些内容可能会让你感到困惑，甚至有些难以理解，但请不要气馁。抽象思维是编程的核心能力之一，它要求你能够从具体的问题中提炼出通用的解决方案，并将其转化为代码。

在这个过程中，你可能会遇到许多挑战：如何优化代码性能？如何设计可扩展的系统架构？如何处理多线程环境下的资源竞争？这些问题都需要你不断学习和实践。每一次的困惑和突破，都是你成长的契机。

记住，编程是一门实践的艺术。理论知识固然重要，但只有通过不断的实践，你才能真正掌握它。不要害怕犯错，错误是学习的最佳老师。每一次调试、每一次优化，都会让你对Java的理解更加深刻。

未来的路或许充满挑战，但也充满机遇。Java的世界广阔无垠，等待着你去探索和征服。继续保持好奇心和学习的热情，勇敢面对每一个抽象的概念和复杂的问题。相信在不久的将来，你将不仅仅是一个Java的使用者，更是一个能够创造价值的开发者。

加油！编程的旅程才刚刚开始，未来的你一定会感谢现在努力的自己。

  • 标题: JAVA基础知识笔记
  • 作者: SIYI171
  • 创建于 : 2025-03-02 20:08:26
  • 更新于 : 2025-07-14 06:22:47
  • 链接: https://blog.siyi171.xyz/2025/03/02/notes-on-the-basic-knowledge-of-java/
  • 版权声明: 本文章采用 CC BY-NC-SA 4.0 进行许可。
评论
目录
JAVA基础知识笔记
  1. 什么是JAVA
  2. 搭建JAVA的开发环境
  3. JAVA程序开发运行流程
  4. Java中的注释使用说明
    1. 注释的分类
  5. 关键字
    1. 关键字的概述
    2. 关键字的特点
  6. 常量
    1. 常量的概念
  7. 数值类型
  8. 变量
    1. 变量的概述
    2. 变量的组成
  9. 标识符
    1. 标识符的概述
    2. 标识符定义规则(硬性要求)
    3. 标识符定义规则(软性要求)
  10. 类型转换
    1. 自动类型转换
    2. 强制类型转换
    3. 表示数值范围从小到大
  11. 算术运算符
  12. 字符的“+”操作
  13. 增自减运算符
  14. 关系运算符
  15. 逻辑运算符
  16. 短路逻辑运算符
  17. 三元运算符
    1. 三元运算符语法格式
    2. 案例1
    3. 案例2
  18. Scanner打印机用法
    1. Sanner使用基本步骤
    2. Scanner类实现求两个数之和
  19. 流程控制语句
    1. 判断语句1－if写法1
    2. 判断语句1－if写法2
    3. 判断语句1－ if案例 奇偶数
    4. 多重if判断语句
    5. switch语句的用法
    6. 循环语句内容
    7. do while循环语句
    8. 死循环
    9. 三种不同循环语句区别
    10. 跳转控制语句
    11. 循环嵌套
    12. Random随机数
  20. 数组概述
    1. 数组定义格式
    2. 数组动态初始化
    3. 数组元素的访问
    4. 1）数组变量的访问方式：数组名
    5. 数组内存分配
    6. 数组静态初始化
    7. 数组的常见问题
    8. 数组的遍历
    9. 数组获取最大值
  21. 方法的概述
    1. 方法定义与调用
    2. 带参数方法的定义和调用
    3. 形参和实参
    4. 带返回值方法的定义和调用
    5. 方法的定义注意事项
    6. 方法的通用格式
    7. 方法的重载
    8. 方法的参数传递基本类型
    9. 方法的参数传递引用类型
  22. 结语