JavaSE学习笔记（一）基础知识
2024-06-06 04:46:15
本章包含内容有：
java环境配置、注释、标识符、数据类型、类型转换、变量、常量、运算符、包机制、顺序结构、选择结构、循环结构、方法的定义和调用、命令行传参、可变参数。
点击这里查看更多JavaSE的笔记
章节目录
- Java基础知识
- 1、JAVA环境配置
- windows平台
- 2、HelloWorld程序猿的第一个程序
- 常见问题
- 3、注释
- 单行注释
- 多行注释
- 文档注释
- 4、Java的标识符
- 关键字
- 标识符
- 5、 Java的数据类型
- 6、Java的类型转换
- 7、Java的变量
- 8、Java的常量
- 9、Java的运算符
- 算术运算符实例
- 关系运算符
- 逻辑运算符
- 位运算
- 扩展运算符
- 三元运算符
- 10、Java的包机制
- 11、Scanner对象
- 12、java的顺序结构
- 13、JAVA的选择结构
- if单选择结构
- if双选择结构
- if多选择结构
- 嵌套的if结构
- switch多选择结构
- 14、Java的循环结构
- while循环
- do...while循环
- for循环
- 增强for循环
- break、continue
- 15、Java的方法定义和调用
- 什么是方法
- 方法的定义和调用
- 方法的重载
- 16、Java命令行传参
- 17、Java的可变参数（不定项参数）
Java基础知识
1、JAVA环境配置
windows平台
首先去官网下载需要的java版本
- 打开软件安装包后傻瓜式安装一直点击下一步
桌面-右键“此电脑”-属性
选择右侧的“高级系统设置”-选择“高级”-选择“环境变量”
在系统变量下新建JAVA_HOME（如图所示）
这里的”变量值“根据JDK的安装路径改变
变量名固定为
JAVA_HOME
在系统变量下新建CLASSPATH（如图所示）
这里的变量名固定为
CLASSPATH
变量值固定为
.;%JAVA_HOME%\lib\dt.jar;%JAVA_HOME%\lib\tools.jar;
修改“Path“变量
- 添加的这两个变量路径是固定的
%JAVA_HOME%\bin
%JAVA_HOME%\jre\bin
最后打开cmd，输入以下指令检查java环境变量是否配置成功。（如果出现类似下图的输出结构代表成功配置java）
java -version
javac
2、HelloWorld程序猿的第一个程序
创建一个文件夹，存放代码
新建一个java文件
文件后缀名为.java
HelloWorld.java
【注意点】系统可能没有显示后缀名，我们需要去把它打开
使用编译软件打开java文件
win平台推荐使用notepad++
mac平台推荐使用sublime text
编写代码
public class HelloWorld{public static void main(String[] args) {System.out.print("HelloWorld!");}
}
- 保存文件，在文件目录下打开终端
- 在终端输入
javac HelloWorld.java
- javac 就是一个编译的命令，编译之后会生成一个class文件
java HelloWorld
- Java 就是一个运行class文件的命令，命令指向的文件不需要输入后缀名
常见问题
- 每个单词的大小写不能出现问题，因为java是大小写敏感的
- 尽量使用英文，因为有的控制台中文会出现乱码
- 文件名和类名必须保持一致，并且首字母大写！
- 符号使用了中文
3、注释
注释并不会执行，只是跟我们人看的。
单行注释
两个英文斜杠后输入注释，但注释只能书写一行。
\\单行注释
多行注释
杠星星杠，在两星之间输入注释，多行注释可以输入一段文字
文档注释
- 参数信息
- @author 作者名
- @version 版本号
- @since 指明需要最早使用的jdk版本
- @param 参数名
- @return 返回值情况
- @throws 异常抛出情况
- 参数信息
使用javadoc命令生成javadoc文档。
javadoc 参数 java文件
- encoding 目标编码
- charset 字符编码
4、Java的标识符
Java所有的组成部分都需要名字。类名、变量名以及方法名都被称为标识符。
关键字
标识符
- 所有的标识符都应该以字母（A-Z或者a-z）、美元符（$）、或者下划线（_）开始。
- 首字母之后可以是字母（A-Z或者a-z）、美元符（$）、或者下划线（_）或数字的任何字符组合。
- 不能使用关键字作为变量名或方法名。
- 表示符是大小写敏感的。
- 可以使用中文命名，但是一般不建议这样去使用，也不建议使用拼音。
5、 Java的数据类型
- 强类型语言
- 要求变量的使用要严格符合规定，所有变量都必须先定义后才能使用
- 弱类型语言
- Java的数据类型分为两大类
- 基本类型（primitive type）
- 引用类型（reference type）
八大基本数据类型
//整数 int num1 = 10; //最常用 byte num2 = 20; short num3 = 30; long num4 = 30L; //Long类型要在数字后面加个L//小数：浮点数 float num5 = 50.2F; //float类型要的数字后面加个F double num6 = 3.1415926; //字符 char name = '请'; //字符串 String不是关键字，它是一个类（这是一个引用数据类型） String namea = "灿彬";//布尔值：是非 boolean flag = true; boolean flag = false;知识科普
- 位（bit）：是计算机内部数据存储的最小单位，11001100是一个八位二进制数。
- 字节（byte）：是计算机忠数据处理的基本单位，习惯上用大写 B 来表示。
- 1B（byte，字节）= 8bit（位）
- 字符：是指计算机中使用的字母、数字、字和符号
拓展
//整数拓展 int i1 = 10; //十进制 int i2 = 010; //八进制 int i3 = 0x10; //十六进制 0～9 A～F int i4 = 0b10; //二进制//浮点数拓展 //银行业务怎么表示？钱 //浮点数都是有限的离散的，它会有舍入误差，所以就会有大约、接近但不等于 //最好不使用浮点数进行比较！！！ //关于浮点数，我们一般使用BigDecimal数学工具类。//字符拓展 char c1 = 'a'; char c2 = '中'; System.out.println(c1); System.out.println((int)c1);//强制转换，输出97 System.out.println(c1); System.out.println((int)c1);//强制转换，输出20013 //得出结论：所有字符本质还是数字 //编码 Unicode 本质是一张表 大小2字节 可以表示对应的65536个字符 //97 = a //65 = A //U0000 ～ UFFFF char c3 = '/u0061'; System.out.println(c3); //输出a//转义字符 // \t 制表符 // \n 换行 System.out.println("Hello\tWorld"); //Hello World System.out.println("Hello\nWorld");//Hello//World
6、Java的类型转换
由于Java是强类型语言，所以要进行有些运算的时候，需要用到类型转换。
- 低 -----------------------------------------> 高
- byte,short,char -> int -> long -> float -> double
运算中，不同类型的数据先转化为同一类型，然后进行运算
强制类型转换
public class Demo1 {public static void main(String[] args) {int a = 128;byte b = (byte)a; //内存溢出,导致得到的值发生变化//强制转换 （类型)变量名System.out.println(a);System.out.println(b);} }
- 自动类型转换
public class Demo1 {public static void main(String[] args) {int a = 128;double b = a;// 自动类型转换 低 --> 高System.out.println(a);System.out.println(b);}
}
注意点：
不能对布尔值进行转换。
不能把对象类型转化为不相干的类型。
把高容量转化为低容量的时候，使用强制转换。
转换的时候可能存在内存溢出、精度问题！
public class Demo1 {public static void main(String[] args) {System.out.println((int)28.8); //double转化成intSystem.out.println((int)33.87f); //float转化为int} }
转换例子
public class Demo1 {public static void main(String[] args) {char a = 'a';int b = a + 1;System.out.println(b);System.out.println((char) b);} }
常见问题
public class Demo1 {public static void main(String[] args) {//操作比较大的数时，要注意溢出问题。//JDK新特性，数字之间可以用下划线分割,对原数据不会产生影响。int money = 10_0000_0000;System.out.println(money);int year = 20;int total = money * year; //-1474836480 计算的时候溢出了System.out.println(total);//错误解决方法long total2 = money * year;System.out.println(total2); //-1474836480 在转换之前就用int计算溢出了//正确解决方法long total3 = money * ((long)year); //先把一个数提升为long类型，整个表达式的数据类型就会提升，不会出现溢出了System.out.println(total3);} }
7、Java的变量
变量是什么？就是可以变化的量。
Java是一种强类型语言，每个变量都必须声明其类型。
Java变量是程序中最基本的存储单元，其要素包括变量名，变量类型和作用域。
//数据类型 变量名 = 值; 可以用逗号隔开来声明多个同类型变量（但使用逗号分隔可读性差）
注意事项
- 每个变量都有类型，类型可以是基本类型，也可以是引用类型。
- 变量名必须是合法的标识符。
- 变量声明是一条完整的语句，因此每一个声明都必须以分号结束。
public class Demo1 {public static void main(String[] args) {//变量的定义String name = "canbin";char h = 'a';double a = 22.32;}
}
变量作用域：
类变量
static int allClicks = 0; //有static //这个类变量会与这个类同共存实例变量
String str = "hello world" //方法外面，类的里面/*如果不自行初始化，就会自动根据类型给一个默认值：布尔值默认是：false常数默认是：0浮点数默认是：0.0String默认是：null（除了基本类型，其它的初始值都是null）*/局部变量
public void method(){int i = 0; //定义在方法内的变量 }
变量的命名规范
所有变量、方法、类名：见名知意
类成员变量：首字母小写和驼峰原则：monthSalary
// 处理第一个单词以外，后面的单词首字母大写
局部变量：首字母小写和驼峰原则
常量：大写字母和下划线：MAX_VALUE
类名：首字母大写和驼峰原则：Man，GoodMan
方法名：首字母小写和驼峰原则：run()，runRun()
8、Java的常量
- 常量（Constant）：初始化（initialize）后不能再改变值！不会变动的值。
- 所谓常量可以理解成一种特殊的变量，它的值被设定后，在程序运行过程中不允许被改变。
- final 常量名 = 值;
- final double PI = 3.14；
- 常量名一般使用大写字符。
public class Demo2 {//修饰符是不分前后顺序的，比如这里的staticstatic final double PI = 3.14;final static double PC = 5.55;public static void main(String[] args) {System.out.println(PI);System.out.println(PC);}
}
9、Java的运算符
- Java语言支持如下运算符：
- 算术运算符：+、-、*、/、%、++、–
- 赋值运算符：=
- 关系运算符：>、<、>=、<=、==、!=、instanceof
- 逻辑运算符：&&、||、!
- 位运算符：&、|、^、~、>>、<<、>>>
- 条件运算符：?、:
- 扩展赋值运算符：+=、-=、*=、/=
算术运算符实例
package operator;public class Demo01 {public static void main(String[] args) {//二元运算符//ctrl+D 复制当前行到下一行int a = 10;int b = 20;System.out.println(a+b);System.out.println(a-b);System.out.println(a*b);System.out.println(a/(double)b); // 因为10除以20的结果是0.5，这里都是int类型会导致小数部分被舍去，所以需要添加一个double对其中一个数进行强制转换。 }
}
package operator;public class Demo02 {public static void main(String[] args) {long a = 333332222;int b = 22222222;short c = 11111;byte d = 22;System.out.println(a+b+c+d); //longSystem.out.println(b+c+d); //intSystem.out.println(c+d); //int//在int及以下的类型，在计算时都会自动提升到int类型//如果出现比int等级还要高的类型，那将会提升到那个类型的等级再进行计算//这里的c+d在jdk17并不会提升到int，只会提升到short，jdk8会提升到int。}
}
package operator;public class Demo03 {public static void main(String[] args) {int a = 10;int b = 21;//取余，也叫做模运算System.out.println(b%a); // 21 / 10 = 2 ... 1 取的就是那个余数}
}
package operator;public class Demo03 {public static void main(String[] args) {int a = 3;int b = a++; //先赋值，然后再自增int c = ++a; //先自增，然后再赋值System.out.println(a); //5System.out.println(b); //3System.out.println(c); //5}
}
关系运算符
package operator;public class Demo03 {public static void main(String[] args) {//关系运算符返回的结果： 正确 错误 布尔值int a = 10;int b = 20;System.out.println(a>b);System.out.println(a<b);System.out.println(a==b);System.out.println(a!=b);}
}
- Math方法
package operator;public class Demo03 {public static void main(String[] args) {//幂运算，我们用的是java里Math的一个pow方法 2^3 2*2*2 = 8//很多运算我们会使用一些工具类来操作！double pow = Math.pow(2, 3);System.out.println(pow);}
}
逻辑运算符
package operator;public class Demo04 {public static void main(String[] args) {// 与（and） 或（or） 非（取反）boolean a = true;boolean b = false;System.out.println(" a && b :" + (a&&b)); // 逻辑与运算：两个都是true的时候，结果才为trueSystem.out.println(" a || b :" + (a||b)); // 逻辑或运算：有一个是true的时候，结果就为trueSystem.out.println(" ! ( a && b ) :" + !(a&&b)); // 如果是真，就变为假。如果是假，就变为真//短路运算int c = 5;boolean d = ( c < 4 )&&( c++ < 4 ); // 在&&前面的是false时，&&后面就不会再执行了System.out.println(c); // c的值没有改变，说明&&后面的c++并没有执行System.out.println(d);}
}
位运算
/*A = 0011 1100B = 0000 1101
A&B = 0000 1100 （都是1的时候取1）
A|B = 0011 1101 （其中一个是1的时候取1）
A^B = 0011 0001 （相同的时候取0，不相同的时候取1）
~B = 1111 0010 （0的时候取1，1的时候取0）<< 左移一位就是乘2
>> 右移一位就是除2
2*8 = 16
2*2*2*2 = 16
2<<3 = 16 (这种位移运算在计算机里效率是最高的)
*/
扩展运算符
package operator;public class Demo05 {public static void main(String[] args) {int a = 3;int b = 5;a+=b; // a = a + ba-=b; // a = a - bSystem.out.println(a);//字符串连接符 +System.out.println(a+b); //8System.out.println(""+a+b); //35//因为前面有一个空的String类型的字符串，所以后面的a和b都被转化为String类型进行拼接了System.out.println(a+b+""); //8//只有运算步骤经过字符串后，才会开始转换成String类型}
}
三元运算符
package operator;public class Demo05 {public static void main(String[] args) {// x ? y : z//当x为true时运行y，当x为false时运行zint score = 50;String type = score<60 ? "不及格" : "及格";System.out.println(type);}
}
10、Java的包机制
为了更好地组织类，Java提供了包机制，用于区别类名的命名空间。
包语句的语法格式为：
package pkg1[.pkg2[.pkg3...]];一般利用公司域名倒置作为包名
- www.baidu.com
- 倒置 => com.baidu.www
为了能够使用某一个包的成员，我们需要在Java程序中明确导入该包，使用“import”语句可完成此功能
import package1[.package2...].(classname|*);package一定是在import上面
import com.canbin.base.*
//这里的 .* 是一个通配符，它会导入base目录下所有的类
11、Scanner对象
之前我们学的基本语法中我们并没有实现程序和人的交互，但是Java给我们提供了这样一个工具类，我们可以获取用户的输入。java.util.Scanner是Java5的新特征，我们可以通过Scanner类来获取用户的输入。
基本语法
Scanner s = new Scanner(System.in);通过Scanner类的**next( )与nextLine( )方法获取输入的字符串，在读取前我们一般需要使用hasNext( )与hasNextLine( )**判断是否还有输入的数据。
实践
- 使用next
package com.canbin.scanner;import java.util.Scanner;public class Demo1 {public static void main(String[] args) {//创建一个扫描器对象，用于接收键盘数据。Scanner scanner = new Scanner(System.in); //这里Scanner需要一个参数 System.in是输入 System.out是输出//使用Scanner对象里hasNext方法，判断用户有没有输入字符串if(scanner.hasNext()){//使用Scanner对象里的next方法接收数据String str = scanner.next(); //程序会等待用户输入完毕System.out.println("输入的字符串是：" + str);}//凡是使用IO流的类，用完不关闭就会一致占用资源。要养成用完就关闭的习惯scanner.close(); //关闭scanner这个类对象} }
- 使用nextLine
package com.canbin.scanner;import java.util.Scanner;public class Demo2 {public static void main(String[] args) {Scanner scanner = new Scanner(System.in);if (scanner.hasNextLine()){String str = scanner.nextLine();System.out.println("您输入的字符串是：" + str);}scanner.close();}
}
next和nextLine差异
- next( )
- 一定要读取到有效字符后才可以结束输入。
- 对输入有效字符之前遇到的空白，next( )方法会自动将其去掉。
- 只有输入有效字符后才将其后面输入的空白作为分隔符或者结束符。
- next( )不能得到带有空格的字符串。
- nextLine( )
- 以Enter为结束符，也就是说nextLine( )方法返回的是输入回车之前的所有字符。
- 可以获得空格。
- next( )
使用hasNext( )能实现判断输入的类型，放入对应的变量容器内。
package com.canbin.scanner;import java.util.Scanner;public class Demo3 {public static void main(String[] args) {int a = 0;float b = 0.0f;Scanner scanner = new Scanner(System.in);if (scanner.hasNextInt()) {a = scanner.nextInt();System.out.println("您输入的是一个整数");System.out.println(a);} else if (scanner.hasNextFloat()) {b = scanner.nextFloat();System.out.println("您输入的是一个小数");System.out.println(b);} else {System.out.println("您输入有误");}//hasNextFloat和hasNextDouble都是包含整数的，就是输入的int类型也会被纳入范围，所有做这种判断的时候，要先从小的单位判断开始scanner.close();} }
Scanner运用
package com.canbin.scanner;import java.util.Scanner;public class Demo4 {public static void main(String[] args) {//我们可以输入多个数字，并求其总和与平均数，每输入一个数字用回车确认，通过输入非数字来结束输入并输出执行结果：Scanner scanner = new Scanner(System.in);//和double sum = 0.0;//计算输入了多少个数字int m = 0;while(scanner.hasNextDouble()){ //判断是不是数字double x = scanner.nextDouble();m++;sum = sum + x;System.out.println("本次是第" + m + "次输入，当前总和是：" + sum);}System.out.println("一共输入：" + m + "次");System.out.println("总和是：" + sum);} }
12、java的顺序结构
java的基本结构就是顺序结构，除非特别指明，否则就按照顺序一句一句执行。
顺序结构是最简单的算法结构。
语句与语句指尖，框与框之间是按从上到下的顺序进行的，它是由若干个依次执行的处理步骤组成的，它是任何一个算法都离不开的一种基本算法结构。
13、JAVA的选择结构
if单选择结构
- 我们很多时候需要去判断一个东西是否可行，然后我们才去执行，这样的一个过程在程序中用if语句来表示。
语法：
if (布尔表达式) {//如果布尔表达式为true将执行的语句 }用例：
package com.xuanze.demo1;import java.util.Scanner;public class ifDemo01 {public static void main(String[] args) {Scanner scanner = new Scanner(System.in);String s = scanner.nextLine();// equals:判断字符串是否相等if (s.equals("hello")){System.out.println(s);}System.out.println("End");scanner.close();} }
if双选择结构
现在有个需求，公司要收购一个软件，成功了，给人支付100万元，失败了，自己找人开发，这样的需求用一个if就搞不定了，我们需要有两个判断，需要一个双选择结构，所以就有了if-else结构。
语法：
if (布尔表达式) {//如果布尔表达式的值为true }else{//如果布尔表达式的值为flse }用例：
package com.xuanze.demo1;import java.util.Scanner;public class IfDemo02 {public static void main(String[] args) {Scanner scanner = new Scanner(System.in);System.out.println("请输入您的成绩：");Double score = scanner.nextDouble();// if双选择结构if (score > 60) {System.out.println("您的成绩及格");}else {System.out.println("您的成绩不及格");}scanner.close();} }
if多选择结构
我们发现刚才的代码不符合实际情况，真实的情况还可能存在ABCD，存在区间多级判断。比如90-100就是A，80-90就是B…等等，在生活中我们很多时候的选择也不仅仅只有两个，所以我们需要一个多选择结构来处理这类问题！
语法：
if(布尔表达式 1){//如果布尔表达式 1的值为true执行代码 }else if(布尔表达式 2){//如果布尔表达式 2的值为true执行代码 }else if(布尔表达式 3){//如果布尔表达式 3的值为true执行代码 }else {//如果以上布尔表达式都不为true执行代码 }用例：
package com.xuanze.demo1;import java.util.Scanner;public class IfDemo03 {public static void main(String[] args) {Scanner scanner = new Scanner(System.in);System.out.println("请输入您的成绩：");Double score = scanner.nextDouble();/*if 语句至多有1个else语句，else语句在所有的else if语句之后。if语句可以有若干个else if 语句，它们必须在else语句之前。一旦其中一个else if语句检测为true，其他的else if以及 else语句就将跳过执行*///if多选择结构if (score == 100){System.out.println("恭喜满分！");}else if (score<100 && score>=90){System.out.println("A级");}else if (score<90 && score>=80){System.out.println("B级");}else if (score<80 && score>=70){System.out.println("C级");}else if (score<70 && score>=60){System.out.println("D级");}else if (score<60 && score>=0){System.out.println("不及格");}else {System.out.println("成绩不合法");}scanner.close();} }
嵌套的if结构
使用嵌套的if…else语句是合法的。也就是说你可以在另一个if或者else if语句中使用if或者else if语句。你可以像if语句一样嵌套else if…else。
语法：
if(布尔表达式 1){//如果布尔表达式 1的值为true执行代码if(布尔表达式 2){//如果布尔表达式 2的值为true执行代码} }
switch多选择结构
多选择结构还有一个实现方式就是switch case语句。
switch case 语句判断奕哥变量与一系列值中某个值是否相等，每个值为一个分支。
switch语句中的变量类型可以是：
- byte、short、int或者char
- 从Java SE 7开始，switch支持字符串String类型了
- case标签必须为字符串常量或字面量
语法：
switch(expression){case value ://当expession与value相等时执行此语句1break;//断开 可选，这里不断开将指向语句1和语句2，直到有break断开为止。这是case穿透现象。case value2 ://当expession与value2相等时执行此语句2break;//断开 可选//你可以有任意数量的case语句default ://可选//以上value、value2都不满足时执行此语句 }用例：
package com.xuanze.demo1;public class SwitchDemo01 {public static void main(String[] args) {String grade = "A";//switch匹配一个具体的值switch(grade){case "A" :System.out.println("满分");break;case "B" :System.out.println("良");//case穿透case "C":System.out.println("合格");case "D":System.out.println("不合格");default:System.out.println("输入不规范");break;}} }
14、Java的循环结构
- 在Java5中引入了一种主要用于数组的增强型for循环。
while循环
while是最基本的循环，它的结构为：
while(布尔表达式){//循环内容 }只要布尔表达式为true，循环就会一直执行下去。
我们大多数情况是会让循环停止下来的，我们需要一个让表达式失败的方式来结束循环
少部分情况需要循环一直执行，比如服务器的请求响应监听等。
循环条件一直为true就会造成无限循环【死循环】，我们正常的业务编程中应该尽量避免死循环，会影响程序性能或者造成程序卡死奔溃！
思考：计算1+2+3+…+100=？
用例 1：
package com.xunhuan;public class XunHuanDemo01 {public static void main(String[] args) {int i = 0;//while循环,输出1~100while (i < 100){System.out.println(++i);}} }用例 2：
package com.xunhuan;public class XunHuanDemo02 {public static void main(String[] args) {//死循环while (true){//监听程序//定时检查程序//.........}} }用例 3：
package com.xunhuan;public class XunHuanDemo03 {public static void main(String[] args) {//计算1+2+3+...+100=?int i = 1;int sum = 0;while( i <= 100){sum = sum + i;i++;}System.out.println(sum);} }
do…while循环
对于while语句而言，如果不满足条件，则不能进入循环。但有时候我们需要即使不满足条件，也至少执行一次。
do…while循环和while循环相似，不同的是，do…while循环至少会执行一次。
do {//代码语句 } while (布尔表达式);while和do…while的区别
- while先判断后执行。do…while是先执行后判断！
- do…while总是保证循环体会被至少执行一次！这是他们的主要差别。
用例 1：
package com.xunhuan;public class XunHuanDemo04 {public static void main(String[] args) {int a = 1;//while循环会判断后再开始循环while (a < 0) { System.out.println(a);a++;}System.out.println("***********************************");//do...while循环无论条件是否成立，都会先执行一次循环体do {System.out.println(a);} while (a < 0);} } /* 输出内容： ======================================================= *********************************** 1进程已结束,退出代码0*/
for循环
虽然所有循环结构都可以用while或者do…while表示，但Java提供了另一种语句——for循环，使一些循环结构变得更加简单。
for循环语句是支持迭代的一种通用结构，是最有效、最灵活的循环结构。
for循环执行的次数是在执行前就确定的。语法格式如下：
for (初始化; 布尔表达式; 迭代更新) {//代码语句 } /* 关于for循环有以下几点说明：最先执行初始化步骤。可以声明一种类型，但可初始化一个或多个循环控制变量，也可以是空语句。然后，检测布尔表达式的值。如果为true，循环体被执行。如果为false，循环终止，开始执行循环体后面的语句。执行一次循环后，更新循环控制变量（迭代因子控制循环变量的增减）。再次检测布尔表达式。循环执行上面的过程。 */练习1，计算0到100之间的奇数和偶数的和
package com.xunhuan;public class ForDemo01 {public static void main(String[] args) {// 计算0到100之间的奇数和偶数的和int oddSum = 0; // 奇数和int evenSum = 0; // 偶数和for (int i = 0; i <= 100; i++) {if (i % 2 == 0){evenSum+=i; // evenSum = evenSum + i;}else {oddSum+=i;}}System.out.println("奇数总和为：" + oddSum);System.out.println("偶数总和为：" + evenSum);} }练习2，用while或for循环输出1~1000之间能被5整除的数，并且每行输出3个
package com.xunhuan;public class ForDemo02 {public static void main(String[] args) {// for循环输出1~1000之间能被5整除的数，并且每行输出3个for (int i = 1; i <= 1000; i++) {if (i % 5 == 0) {System.out.print(i + "\t\t");}if (i % (5*3) == 0) {System.out.println();}}System.out.println();System.out.println("===================================================================");// while循环输出1~1000之间能被5整除的数，并且每行输出3个int m = 1;while (m <= 1000) {if (m % 5 ==0) {System.out.print(m + "\t\t");}if (m % (5*3) ==0) {System.out.println();}m++;}} }练习3，打印九九乘法表
package com.xunhuan;public class ForDemo03 {public static void main(String[] args) {// 输出九九乘法表// 1、先打印第一列// 2、把固定的1再用一个循环包起来// 3、去掉重复项，i <= j// 4、调整样式for (int a = 1; a <= 9; a++) {for (int b = 1; b <= a; b++) {System.out.print(a + "*" + b + "=" + (a*b) + "\t\t");}System.out.println();}} }
增强for循环
这里我们先只是见一面，做个了解，之后数组我们重点使用
Java5引入了一种主要用于数组或集合的增强型for循环。
Java增强for循环语句格式如下：
for(声明语句 : 表达式){//代码句子 }声明语句：声明新的局部变量，该变量的类型必须和数组元素的类型匹配。其作用域限定在循环语句块，其值与此时数组元素的值相等。
表达式：表达式是要访问的数组名，或者是返回值为数组的方法。
用例：
package com.xunhuan;public class ForDemo04 {public static void main(String[] args) {int [] numbers = {10,20,30,40,50}; //定义了一个数组//for循环遍历数组元素for (int i = 0; i < 5; i++) {System.out.println(numbers[i]);}System.out.println("=====================================================");//增强for遍历数组的元素for (int x : numbers) { //这里只是把numbers数组里的值一个一个赋值给xSystem.out.println(x);}} }
break、continue
break在任何循环语句的主体部分，均可用break控制循环的流程，break用于强行退出循环，不执行循环中剩余的语句。（break语句也在switch语句中使用）
continue语句用在循环语句体中，用于终止某次循环过程，即跳过循环体中尚未执行的语句，接着进行下一次是否执行循环的判定。
关于goto关键字
- goto关键字很早就在程序设计语言中出现，尽管goto仍是Java的一个保留字，但并未在语言中得到正式使用：Java没有goto。然而，在break和continue这两个关键字的身上，我们仍然能看出一些goto的影子——带标签的break和continue。
- “标签”是指后面跟一个冒号的标识符，例如：label:
- 对Java来说唯一用到标签的地方是在循环语句之前，而在循环之前设置标签的唯一理由是：我们希望在其中嵌套另一个循环，由于break和continue关键字通常只中断当前循环，但若随同标签使用，它们就会中断存在标签的地方。
break用例：
package com.xunhuan;public class BreakDemo01 {public static void main(String[] args) {int i =0;while (i < 100) {i++;System.out.println(i);if (i == 30) {break; //跳出循环，但不会终止程序}}System.out.println("123");} }continue用例：
package com.xunhuan;public class ContinueDemo01 {public static void main(String[] args) {int i = 0;while (i < 100) {i++;if (i % 10 == 0) {System.out.println();continue; //从这里终止本次循环执行的语句，继续下一次循环}System.out.print(i + "\t");}// break在任何循环语句的主体部分，均可用break控制循环的流程。（switch、for、while）// break用于强行退出循环，不执行循环中剩余的语句。// continue语句用在循环语句体中，用于终止某次循环过程，即跳过循环体中尚未执行的语句，接着进行下一次是否执行循环的判定。} }标签用例：
package com.xunhuan;public class LabelDemo01 {public static void main(String[] args) {//打印101~150之间所有的质数//质数是指大于1的自然数中，除了1和它本身以外不再有其他因数的自然数。（就是除了1和它本身以外不会被其他自然数整除）//不建议使用这种标签！！！outer:for (int i = 101; i < 150; i++) {for (int j = 2; j < i/2; j++) {if (i % j == 0) {continue outer; //终止本次outer标签的循环，继续下一次outer循环}}System.out.print(i + "\t");}} }打印三角形
package com.xunhuan;public class TestDemo01 {public static void main(String[] args) {//打印三角形 五行for (int i = 1; i <= 5; i++) {for (int j = 5; j >= i; j--) {System.out.print("-");}for (int j = 1; j <= i; j++) {System.out.print("*");}for (int j = 1; j < i; j++) {System.out.print("*");}System.out.println();}} }/* 运行结果: ================================================================*************************进程已结束,退出代码0 ================================================================ */
15、Java的方法定义和调用
什么是方法
System.out.println()，那么它是什么呢？
- System是一个类
- out是一个对象
- println是一个方法
Java方法是语句的集合，它们在一起执行一个功能。
- 方法是解决一类问题的步骤的有序组合。
- 方法包含于类或对象中。
- 方法在程序中被创建，在其他地方被引用。
设计方法的原则：方法的本意是功能块，就是实现某个功能的语句块的集合。我们设计方法的时候，最好保持方法的原子性，就是一个方法只完成一个功能，这样利于我们后期的扩展。
回顾：方法的命名规则？
- 首单词小写，后面单词首字母大写，骆驼峰命名规则
用例：
package com.method;public class Demo01 {//main方法public static void main(String[] args) {int i = add(10, 20); //这里的10, 20是实际参数，实际调用传递给方法的参数。System.out.println(i);text();}//加法//这里的int a, int b是形式参数，用来定义作用的。public static int add(int a, int b) { //添加static使方法称为类方法方便调用。return a+b;}public static void text() {// 输出九九乘法表for (int a = 1; a <= 9; a++) {for (int b = 1; b <= a; b++) {System.out.print(a + "*" + b + "=" + (a*b) + "\t\t");}System.out.println();}} }
方法的定义和调用
Java的方法类似于其他语言的函数，是一段用来完成特定功能的代码片段，一般情况下，定义一个方法包含以下语法：
修饰符 返回值类型 方法名（参数类型 参数名）{。。。方法体return 返回值; }方法包含一个方法头和一个方法体。下面是一个方法的所有部分：
- 修饰符：修饰符，这是可选的，告诉编译器如何调用该方法。定义了该方法的访问类型。
- 返回值类型：方法可能会返回值。returnValueType是方法返回值的数据类型。有些方法执行所需的操作，但没有返回值。这种情况下，returnValueType是关键字void。
- 方法名：是方法的实际名称。方法名和参数表共同构成方法签名。
- 参数类型：参数像是一个占位符。当方法被调用时，传递值给参数。这个值被称为实参或变量。参数列表是指方法的参数类型、顺序和参数的个数。参数是可选的，方法可以不包含任何参数。
- 形式参数：在方法被调用时用于接收外界输入的数据。
- 实参：调用方法时实际传给方法的数据。
- 方法体：方法体包含具体的语句，定义该方法的功能。
- return：当这个方法有返回值时，必须使用return返回出去，而且返回值的类型必须与定义时写的方法返回值类型一致，如果定义方法的返回值类型为void的话，那说明此方法没有返回值。
调用方法：对象名.方法名(实参列表)
Java支持两种调用方法的方式，根据方法是否返回值来选择。
当方法返回一个值的时候，方法调用通常被当做一个值。例如：
int larger = max(30, 40);如果方法返回值时void，方法调用一定是一条语句。
System.out.println("Hello,wukunyan!");用例：
package com.method;public class Demo02 {public static void main(String[] args) {System.out.println(max(30,30));}//比较大小public static int max(int num1, int num2) {int result;if (num1 == num2) {System.out.println("num1=num2");return 0; //可以使用return 0;终止方法}if (num1 > num2) {result = num1;}else {result = num2;}return result;} }
方法的重载
重载就是在一个类中，有相同的函数名称，但形参不同的函数。
方法的重载规则：
- 方法名称必须相同
- 参数列表必须不同（个数不同、或类型不同、参数排列顺序不同等）
- 方法的返回类型可以相同也可以不相同
- 仅仅返回类型不同不足以成为方法的重载
实现理论：
- 方法名称相同时，编译器会根据调用方法的参数个数、参数类型等去逐个匹配，以选择对应的方法，如果匹配失败，则编译器报错。
用例：
package com.method;public class Demo02 {public static void main(String[] args) {double i = max( 33.4, 34.5);System.out.println(i);int j = max(44, 55, 55);System.out.println(j);System.out.println(max(30,30));}//比大小public static int max(int num1, int num2) {int result;if (num1 == num2) {System.out.println("num1=num2");return 0; //可以使用return 0;终止方法}if (num1 > num2) {result = num1;}else {result = num2;}return result;}//重载1public static double max(double num1,double num2) {double result;if (num1 == num2) {System.out.println("num1=num2");return 0; //可以使用return 0;终止方法}if (num1 > num2) {result = num1;}else {result = num2;}return result;}//重载2public static int max(int a, int b, int c) {int result = b;if (a > b) {b = a;}if (a < c) {result = c;}return result;} }
16、Java命令行传参
有时候你希望运行一个程序时候再传递给它消息。这要靠传递命令行参数给main()函数实现
用例：
package com.method;public class Demo03 {public static void main(String[] args) {for (int i = 0; i < args.length; i++) {System.out.println("args[" + i + "]=" +args[i]);}} }命令行操作：
Microsoft Windows [版本 10.0.19044.1645] (c) Microsoft Corporation。保留所有权利。E:\java后端\Novice\demo\untitled\src\com\method>javac Demo03.javaE:\java后端\Novice\demo\untitled\src\com\method>cd ../E:\java后端\Novice\demo\untitled\src\com>cd ../E:\java后端\Novice\demo\untitled\src>java com.method.Demo03E:\java后端\Novice\demo\untitled\src>java com.method.Demo03 this is wukunyan args[0]=this args[1]=is args[2]=wukunyan
17、Java的可变参数（不定项参数）
JDK 1.5开始，Java支持传递同类型的可变参数给一个方法（就是传递多个同类型的参数，具体多少个不一定，它们本质上就是一个集合）
在方法声明中，在指定参数类型后加一个省略号(…)
一个方法中只能指定一个可变参数，它必须是方法的最后一个参数。任何普通的参数必须在它之前声明
package com.method;public class Demo04 {//求最大值public static void main(String[] args) {max(666,444,54.54654564);}public static void max(double... num) {if (num.length == 0) {System.out.println("没有收到参数");return;}double result = -1;for (double v : num) { //遍历num数组中的每一个值给到vif (v > result) {result = v;}}System.out.println("最大值为：" + result);} }
如果有同学发现笔记存在问题，麻烦私信找我，我马上来更正，谢谢！
JavaSE学习笔记（一）基础知识相关推荐
- php基础教学笔记,php学习笔记：基础知识
php学习笔记:基础知识 2.每行结尾不允许有多余的空格 3.确保文件的命名和调用大小写一致,是由于类Unix系统上面,对大小写是敏感的 4.方法名只允许由字母组成,下划线是不允许的,首字母要小写,其 ...
- 【学习笔记--FMCW基础知识】
学习笔记--FMCW基础知识 前言 mmWave测距原理 mmWave区分多个物体 mmWave的距离分辨率(Range Solution) mmWave的最大测量距离 前言 由于工作原因需要了解TI ...
- HTML5学习笔记 —— JavaScript基础知识
HTML5学习笔记 -- JavaScript基础知识 标签: html5javascriptweb前端 2017-05-11 21:51 883人阅读 评论(0) 收藏 举报 分类: JavaScr ...
- SAS学习笔记1——基础知识（库、PDV、变量选择、观测值排序、创建新变量
SAS学习笔记1--基础知识 1.逻辑库.临时库.永久库 2.数据步 2.1数据步语法 2.2 数据步的编译和执行过程 2.3变量的选择 2.3.1 keep和drop语句 2.4变量的重命名rena ...
- JS学习笔记——入门基础知识总结
JS入门基础知识总结1 前言 基础背景知识 一.产生历史: 二.特点: 三.应用方向: 四.Javascript组成: JavaScript书写使用方式 一.行内式(了解即可,项目中不使用,日常练习尽 ...
- 《UNIX 环境高级编程》学习笔记——UNIX 基础知识
UNIX环境高级编程--UNIX 基础知识 引言 UNIX 体系结构 登录 文件和目录 输入和输出 程序和进程 出错处理 用户标识 信号 时间值 系统调用和库函数 引言 所有操作系统都为它们所允许的程 ...
- 单片机学习笔记——微机基础知识
微机基础知识 微处理器,微机和单片机概念 微处理器的组成 一.运算器 主要寄存器 主要寄存器(IR),指令译码器(ID) 程序计数器(PC) 地址寄存器(AR) 二.控制器 存储器和输入输出接口 一. ...
- CAN总线学习笔记 | CAN基础知识介绍
一.CAN协议 1.1 CAN协议简介 CAN 是控制器局域网络 (Controller Area Network) 的简称,它是由研发和生产汽车电子产品著称的德国 BOSCH 公司开发的,并最终成为 ...
- WebGL学习笔记（基础知识篇）
WEBGL基础知识介绍 1.场景(scene) 场景如其名,即显示3D空间内物体的容器,就好比一个箱子是一个3D场景. 2.坐标系: webgl使用笛卡尔坐标系(宽度.高度和深度),我们也可以指定使用 ...
- RocketMQ学习笔记：基础知识和安装启动
这是本人学习的总结,主要学习资料如下 马士兵教育 rocketMq官方文档 目录 1.架构 2.基本概念 3.安装和启动 3.1.命令行启动 3.1.1.启动Server 3.1.2.启动Broker ...
最新文章
- linux命令学习之：curl
- C# WinFrom 去掉groupbox的边框
- 【渝粤题库】国家开放大学2021春1020国际私法题目
- 初步学习pg_control文件之六
- 开着开着，Model S天窗飞了！特斯拉回应...
- [转载]与索引相关的概念---聚簇因子
- python map对象
- 服务器外置硬盘安装教程,小容量Mac用户必看——苹果电脑外接硬盘安装windows教程...
- 网易你收集用户身份证扫描件意欲何为——隄防维权背后的个人信息安全陷阱
- Md5加密算法的原理及应用
- Java集合 HashSet 和 HashMap
- Python安装distribute包
- thinkpad笔记本电脑怎么关闭触摸板
- 服务器1521端口被关闭，如何开启
- 2022年「博客之星」参赛博主：hyk今天写算法了吗
- 2008年新作——《网管员面试宝典》上市了
- Django QuerySet优化
- 【开源要闻】Canonical发布新OpenStack工具、Kubernetes访客引导方法
- python 打印文件_在Python中打印word文档
- css布局-浮动、定位、flex布局