java基础

目录

• java入门知识：
  
  
  
  • 一、开发环境
    
  • 二、关系
    
  • 三、变量
    
  • 四、标识符
    
    
    
    • 一、标识符命名的规则
      
    • 二、标识符命名规范
      
      
      
      • 1、标识符的命名规则：
        
        
        
        • 2、标识符的命名规范：
          
        
        
      • 3、变量的声明格式，变量的赋值格式，变量的三要素，变量应该留意几点
        
      • 4、java基本数据范例有哪些？
        
      • 5、java程序的开发步调是什么？
        
      
      
    
    
  • 五、运算符
    
    
    
    • 一、算术运算符
      
    • 二、赋值运算符
      
    • 三、比较运算符，也称为关系运算符
      
    • 四、扩展赋值运算符
      
    • 五、条件运算符：唯一的三元运算符
      
    • 六、位运算符：
      
    
    
  • 六、程序流程控制
    
    
    
    • 1. 顺序布局
      
    • 2. 分支布局
      
      
      
      • 2.1分支布局
        
      • 2.2条件判断：if...else
        
      • 2.3单分支
        
      • 2.4双分支：if...else
        
      • 2.4多分支布局
        
      • 2.6 选择布局
        
      
      
    • 3. 循环布局
      
      
      
      • 3.1 while循环
        
      • 3.2 do...while循环
        
      • 3.3 for循环
        
      
      
    
    
  
  

java入门知识：

一、开发环境

• jdk  java开发工具包，全称为 java develpment kit
  
• jre  java 运行环境，(java runtime Environment)
  
• jvm  java 虚拟机，(java Virtual Machine)
  

二、关系

• JDK = JRE + 开发工具（javac.exe，java.exe，javadoc.exe..）
  
• JRE = JVM + 标准的核心的类库
  

三、变量

变量的三要素：

• 变量名
  
• 数据范例
  
• 变量值
  

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