ToB企服应用市场:ToB评测及商务社交产业平台

标题: java基础 [打印本页]
作者: 卖不甜枣    时间: 2024-5-12 15:54
标题: java基础
目录

java入门知识：

一、开发环境

二、关系


三、变量

变量的三要素：
  1. public class BianLiang {
  3.     public static void main(String[] args) {
  5.         int age;
  6.         age = 18;
  7.         System.out.println("我今年的年龄是：" + age);
  8.     }
  11. }
复制代码
四、标识符

概念：
java 对各种变量、方法和类等要素命名的时间使用的字符串叫做标识符
比如：类名、变量名、包、常量名.....
一、标识符命名的规则

1、JAVA的标识符只能用26个英文字母（大小写）、0 -9 的数字、美元符号、下划线（_）
2、数字不能开头
3、不能包罗空格
4、严格区分大小写
5、不能使用JAVA的关键字和保存字、特别键
二、标识符命名规范

1、类名、接口名等：每一个单词首字母大写、情势XxxxYxx
2、变量名、方法名：第一个单词字母小写，第二个单词首字母大写：情势xxxYyy
3、包名：全部小写，情势 xxx .yyy.zzz 例如： java.long
4、常量名：全部大写,情势：XXX_YYY_ZZZ 例如：PI
总则： 见名知意
1、标识符的命名规则：
  1. 1. Java的标识符只能用26个英文字母，大小写，数字0-9，美元符号（$),下划线（_）
  2. 2. 数字不能开头
  3. 3. 不能包含空格
  4. 4. 严格区分大小写
  5. 5. 不能使用关键字，保留字，特殊值
复制代码
2、标识符的命名规范：
  1. 1. 类名：每个单词的首字母必须大写，形式是XxxYyy
  2. 2. 变量名、方法名等：第一个单词首字母小写，其余单词首字母大写
  3. 3. 包名：所有单词都小写，形式是xxx.yyy.zzz
  4. 4.常量：所有单词都要大写，形式XXX_YYY_ZZZ，例如：PI，MAX_VALUE
  5. - 总则：见名思意
复制代码
3、变量的声明格式，变量的赋值格式，变量的三要素，变量应该留意几点
  1. - 变量的声明格式：数据类型 变量名；
  2. - 变量的赋值格式：变量名 = 值；
  3. - 变量的三要素： 数据类型 变量名 变量值
  4. - 变量的使用应该注意：
  5.     1）先声明后使用
  6.     2）使用之前必须赋初始化值
  7.     3）变量的作用域
  8.        作用:从声明处开始到所属的}结果
  9.        同一个作用域中不能重复声明一个变量
复制代码
4、java基本数据范例有哪些？
  1. 1. 基本数据类型
  2.    byte,short,int,long,float,double,char,boolean
  3. 2. 引用数据类型
  4.    类，接口，数组，枚举
  5.    String 属于类 ，引用数据类型
复制代码
5、java程序的开发步调是什么？
  1. 1.编辑：
  2.   编写源文件，保存为.java文件
  3.   class 类名{
  4.         方法{
  5.         语句
  6.         }
  7.   }
  8. 2.编译：
  9.   编译的结果是：.java 的源文件编译为成一个或多个.class 文件
  10.   编译的工具是：javac.exe
  11.   编译的命名格式是：java 源文件名.java
  12. 3. 运行：
  13. 运行的工具是：java.exe
  14. 运行的格式是：java 类名
  15. 这个类必须包含main方法，main方法的格式是：public static void main(String[] arg[])
复制代码
五、运算符

一、算术运算符
  1. 1. 加、减、乘，除,取余（取余）： +,-,*,/,%
  3.     除法：如果两个证书相除，结果只保留整数部分
  4.     // 取余： 模数的符号被忽略
  5.            被模数%模数
  7. 2. 正号、负号： + ，-
  9.        运算符：一元运算符，二元运算符，三元运算符
  10.        根据需要的操作数的不同
  12. 3.如果有一边是字符串，都是字符串拼接
  14. 4. 自增
  16.       i++   先 取出i的值，参与别的运算，然后a再自增1
  17.       ++i·   先运算a的自增，然后用i自增的结果i自增的结果在参与别的运算
复制代码
二、赋值运算符

1、基本赋值运算符：=
  1. 把=右边的值赋值给左边的变量。
  2. 右边的值有各种形式：
  3.     （1）常量值
  4.     （2）表达式的值
  5.     （3）方法（函数）调用的结果
复制代码
三、比较运算符，也称为关系运算符
  1. - 大于：>
  2. - 小于：<
  3. - 大于等于：>=
  4. - 小于等于：<=
  5. - 等于：== 注意区分赋值的=
  6. - 不等于：!=
  8. **=,<=,==,!=中间不能有空格**
  10. 关系运算符的表达式的结果只有两种：true/false
复制代码
六、位运算符：
  1. > += ，-=，*=, /=， %= ，...
  3. 说明：前面的运算符与=之前不能有空格
  4. 注意：扩展赋值运算符要警惕它隐含了强转类型转换，有风险，可能溢出，和损失精度（总之，结果与预期不同）
复制代码
六、程序流程控制

流程控制语句是用来控制程序中各语句实行顺序的语句，可以把语句组合成能完成肯定功能的小逻辑模块
主要分为三个：
1. 顺序布局

程序从上到下实行，中间没有任何判断和跳转
  1. 语法格式：
  2.     > 条件表达式 ？ 表达式1 : 表达式2
  4. 说明：
  5.     （1）条件表达式必须是一个boolean结果的表达式
  6.     （2）如果条件表达式为true，整个表达式的结果就取表达式1的结果，否则就取表达式2的结果
复制代码
2. 分支布局

根据条件，选择性地实行某段代码
2.1分支布局

（1）条件判断：if...else
（2）选择布局：switch...case
2.2条件判断：if...else

（1）单分支
（2）双分支
（3）多分支
（4）嵌套
2.3单分支

语法布局：
  1. 位移:只能作用于long.int,short,byte,char 这四种基本数据类型
  3. 1、右移：>>
  5.     左边不够的补xx，补什么看最高位，最高位是0就补0，是1就补1
  6.     简单的算法：右移几位，相当于除以2的几次方
  8. 2、左移：<<
  10.     左移，右边补0
  11.     简单的算法：左移几位，相当于乘以2的几次方
  13. 3、无符号右移：>>>
  15.     左边的不管最高位是xx，统统都补0
  17. 4、按位与：&
  19.     1 & 1 结果是1
  20.     1 & 0 结果为0
  21.     0 & 1 结果为0
  22.     0 & 0 结果为0
  24. 5、按位或：|
  26.     1 | 1 结果是1
  27.     1 | 0 结果为|
  28.     0 | 1 结果为|
  29.     0 | 0 结果为0
  31. 6、按位异或：^
  33.     1 ^ 1 结果是0
  34.     1 ^ 0 结果为|
  35.     0 ^ 1 结果为|
  36.     0 ^ 0 结果为0
  38. 7、按位取反：~
  40.     位运算符是用整数的二进制，并且是补码来运算的。
  41.     开发很少用，但是源代码中有
  42.     在Java程序中可能会出现多种进制：
  43.     二进制：计算机所有数据都是二进制
  44.     数字：0-1
  45.     逢二进一
  46.     十进制：生活中，人更习惯十进制，结果显示都是十进制
  47.     数字：0-9
  48.     逢十进一
  49.     八进制：
  50.     数字：0-7
  51.     逢八进一
  52.     十六进制：
  53.     数字：0-9，A(a)-F(f)
  54.     逢十六进一
  56. 八进制和十六进制都是辅助表示二进制
  58. 1、在程序中如何表示某个数字是几进制的？
  59. 十进制：默认
  60. 二进制：数字前加0b或0B
  61. 八进制：数字前加0
  62. 十六进制：数字前加0X或0x
复制代码
实行的特点：
当某个条件建立，就实行，不建立就什么也不干
说明：
（1）if()中写条件表达式，必须是布尔范例
A：关系表达式
B：逻辑表达式
C：布尔变量
（2）假如{}中只有一个语句，那么可以省略{}
但是：习惯上，我们就算只有一个语句，也保存{}
  1. public class Test{
  2.         int num1 = 12;
  3.         //执行语句1
  4.         int num2 = num1 + 2;
  5. }
复制代码
2.4双分支：if...else

语法布局：
  1. if(条件表达式){
  2.         当条件表达式为true，即条件成立时，需要执行的语句块;
  3. }
复制代码
实行的特点：
这两个分支只实行其中一个，
当条件表达式建立时，实行的语句块1;
当条件表达式不建立时，实行的语句块2;
说明：
（1）if()中写条件表达式，必须是布尔范例
A：关系表达式
B：逻辑表达式
C：布尔变量
（2）假如{}中只有一个语句，那么可以省略{}
但是：习惯上，我们就算只有一个语句，也保存{}
  1. public static void main(String[] args){
  2.         //当某个条件成立，就执行，不成立就什么也不干
  3.         //例如：如果年满18岁，就让你进入我的系统
  4.         int age = 14;
  5.         if(age >= 18){
  6.             System.out.println("欢迎您进入成人世界。。。。");
  7.             System.out.println("玩的尽兴...");
  8.         }
  10.     }
复制代码
2.4多分支布局

语法布局：
  1. if(条件表达式){
  2.     当条件表达式成立时，执行的语句块1;
  3. }else{
  4.     当条件表达式不成立时，执行的语句块2;
  5. }
复制代码
实行特点：
（1）先判断条件表达式1，假如条件表达式1建立，那么就实行语句块1，后面的分支齐备都不看，也不实行
（2）假如条件表达式1不建立，接着看条件表达式2，假如条件表达式2建立，那么就实行语句块2，
前面的语句块1，和后面的语句块都不实行，后面的条件也不看了。
（3）依次类推
（4）假如全部的条件都不建立，假如此时存在单独的else，那么实行else中的语句块n+1，假如else不存在，那么就都不实行。
说明：
（1）【】表示可选，可能有可能没有
（2）全部的条件表达式都要是布尔值
（3）全部的分支，假如只有一个语句，对应的{}仍旧可以省略，但是强烈建议都保存。
（4）假如多个if的条件的范围是互斥，没有重叠部门，那么是顺序可以调换
假如多个if的条件的范围是包罗，有重叠部门，那么顺序有要求，范围小的在上，大的在下
  1. public static void main(String[] args){
  2.         //例如：如果年满18岁，就让你进入我的系统，否则，提示未成年不得进入
  3.         int age = 19;
  4.         if(age >= 18){
  5.             System.out.println("欢迎您进入成人世界。。。。");
  6.             System.out.println("玩的尽兴...");
  7.         }else
  8.             System.out.println("未成年不得进入");
  10.     }
复制代码
2.6 选择布局

语法格式：
  1. if(条件表达式1){
  2.     当条件表达式1成立，执行语句块1;
  3. }else if(条件表达式2){
  4.     当条件表达式2成立，执行语句块2;
  5. }【else if(条件表达式3){
  6.     当条件表达式2成立，执行语句块3;
  7. }】
  8. ....
  9. 【else{
  10.     当以上所有的条件表达式都不成立，执行语句块n+1;
  11. }】
复制代码
实行特点：
“入口”：
A：当表达式的值与其中一个case的常量值匹配，就从这个分支进入，一旦进入顺序往下实行
B：当表达式的值与全部的case都不匹配，假如此时存在default，就从default进入，一旦进入顺序往下实行
“出口”：
A：遇到switch的竣事}
B：遇到break
说明：
（1）switch()中的表达式的范例也有要求：
只能是以下几种范例：byte,short,int,char四种基本数据范例，
JDK1.5以后答应支持 枚举范例（引用数据范例）
JDK1.7以后答应支持 String范例（引用数据范例）
（2）case后面必须是常量值或常量表达式
（3）case后面的常量值的范例必须与switch()中表达式的范例同等或兼容
（4）case后面的常量值不能重复
和if..else:
全部的分支情况，都可以使用if..else，换句话说，可以使用switch..case解决的，肯定可以使用if..else。
但是当全部的判断都是常量值的等值判断的话，使用switch..case效率更高，可读性更好。
  1.    public static void main(String[] args){
  2.         //例子：从键盘输入一个成绩
  3.         //假设成绩输入都是合理的[0,100]
  4.         //如果是100分，那么就打印满分
  5.         //如果是[80,99]，那么就打印优秀
  6.         //如果是[70,80)，那么就打印良好
  7.         //如果是[60,70)，那么就打印及格
  8.         //否则都不及格
  9.         Scanner input = new Scanner(System.in);
  11.         System.out.print("请输入成绩：");//提示输入
  12.         //接收键盘输入
  13.         int score = input.nextInt();
  15.         //判断
  16.                 /*
  17.                 if(score == 100){
  18.                         System.out.println("满分");
  19.                 }else if(score>=80 && score<=99){
  20.                         System.out.println("优秀");
  21.                 }else if(score>=70 && score<80){
  22.                         System.out.println("良好");
  23.                 }else if(score>=60 && score<70){
  24.                         System.out.println("及格");
  25.                 }else{
  26.                         System.out.println("不及格");
  27.                 }
  28.                 //条件互斥：每一个条件没有重叠部分
  29.                 */
  31.         //前提仍然是成绩在[0-100]
  32.         if(score == 100){
  33.             System.out.println("满分");
  34.         }else if(score>=80){
  35.             System.out.println("优秀");
  36.         }else if(score>=70){
  37.             System.out.println("良好");
  38.         }else if(score>=60){
  39.             System.out.println("及格");
  40.         }else{
  41.             System.out.println("不及格");
  42.         }
  43.         //条件包含：仅看条件的范围是有重叠和包含部分
  45.     }
复制代码
3. 循环布局

根据循环条件，重复的实行某段代码有 while、do...while 、for 三种循环语句
3.1 while循环

语法布局：
  1. switch(表达式){
  2.     case 常量值1:
  3.        语句块1;
  4.        【break;】
  5.     case 常量值2:
  6.        语句块2;
  7.        【break;】
  8.     ...
  9.     【
  10.     default:
  11.        语句块n+1;
  12.        【break;】
  13.     】
  14. }
复制代码
实行过程：
（1）先上来就判断循环条件
（2）假如条件建立，就实行循环体
（3）回到（1）
（4）直到循环条件不建立竣事
循环的四个要素：
（1）循环变量的初始化
（2）循环条件
（3）循环体
（4）迭代表达式：用于修改循环变量的值
for循环比较适用于：起点和终点比较明显，例如1-100，具体多少次，3000米到5米
while循环，适用于，循环条件明显，次数不确定不固定
  1.     public static void main(String[] args){
  2.         //根据星期的数字值，输出对应的星期的英文单词
  3.         Scanner input = new Scanner(System.in);
  4.         System.out.print("请输入星期：");
  5.         int week = input.nextInt();
  7.         switch(week){
  8.             case 1:
  9.                 System.out.println("Monday");
  10.                 break;
  11.             case 2:
  12.                 System.out.println("Tuesday");
  13.                 break;
  14.             case 3:
  15.                 System.out.println("Wednesday");
  16.                 break;
  17.             case 4:
  18.                 System.out.println("Thursday");
  19.                 break;
  20.             case 5:
  21.                 System.out.println("Friday");
  22.                 break;
  23.             case 6:
  24.                 System.out.println("Saturday");
  25.                 break;
  26.             case 7:
  27.                 System.out.println("Sunday");
  28.                 break;
  29.             default:
  30.                 System.out.println("输入有误，星期的范围是1-7");
  31.                 break;
  32.         }
  33.     }
复制代码
3.2 do...while循环
  1. while(循环条件){
  2.     循环体：需要重复执行的语句块
  3. }
复制代码
实行的过程：
(1)先实行一次循环体语句
(2)再判断循环条件
(3)假如条件建立，为true，再次实行循环体
(4)回到(2)
(5)直到循环条件不建立，为false，竣事循环
假如循环的条件比较明显，但是不像for那样，起始和终止条件比较明确，次数比较明显，
选择while，当出现至少循环体要实行一次，这样可以改为do...while
三种循环都是可以无条件交换的。
3.3 for循环

语法布局：
  1. public static void main(String[] args) {
  2.     // 从键盘不断输入整数，统计正数、负数的个数，输入0结束
  3.     Scanner input = new Scanner(System.in);
  5.     System.out.println("请输入一个整数：");
  6.     int num = input.nextInt();
  8.     int zheng = 0;
  9.     int fu = 0;
  11.     while (num != 0) {
  12.         if (num > 0) {
  13.             zheng++;
  14.         } else if (num < 0) {
  15.             fu++;
  16.         }
  18.         System.out.println("请输入一个整数：");
  19.         num = input.nextInt();
  20.     }
  22.     System.out.println("正数的个数：" + zheng);
  23.     System.out.println("负数的个数：" + fu);
  24. }
复制代码
说明：
（1）for(;;)两个分号不能省略
（2）只有需要重复实行多次的代码才能放到循环体中{}
（3）需要加上条件等来控制循环的次数，否则就是死循环
语法布局：
  1. do{
  2.     循环体：需要重复执行的代码
  3. }while(循环条件);
复制代码
实行过程：
（1）先实行【初始化表达式1】
（2）判断【循环条件表达式2】是否建立，为true
（3）假如建立，就实行循环体语句块4
（4）接着实行【迭代表达式3】
（5）回到（2）
（6）直到【循环条件表达式2】不建立，为false，然后就竣事
循环嵌套：
外循环循环一次，内循环循环一轮
[code]public static void main(String[] args){    for(int i=1; i



欢迎光临 ToB企服应用市场:ToB评测及商务社交产业平台 (https://dis.qidao123.com/) Powered by Discuz! X3.4