Java筑基（一）

Java筑基

• 一、java中的第一个程序
• 二、java中注释
• • 2.1、单行注释
  • 2.2、多行注释
  • 2.3、文档注释
  • 三、java跨平台实现原理
  • 四、标识符、关键字、保留字
  • 五、变量
  • • 5.1、作用
    • 5.2、分类
    • • 5.2.1、**属性：默认会被赋值**
      • 5.2.2、局部变量：
      • 5.2.3、作用域
      • 5.2.4、变量的定义
      • 六、java中数据类型
      • • 6.1、数据类型：两大类
        • 6.2、基本数据类型：四大类，有8个
        • • 6.2.1、整型：4个，默认值为0，默认类型为int
          • 6.2.2、字符型：有且只有一个，默认为```''```
          • 6.2.3、浮点型：两大类，默认类型为double，默认值为0.0
          • 6.2.4、布尔型：只有1个
          • 6.2.5、从小到大的顺序
          • 6.3、引用数据类型：三大类，无数个，默认值都为null
          • 七、基本数据类型的运算规则
          • 八、运算符
          • • 8.1、算术运算符
            • 8.2、赋值运算符
            • 8.3、比较运算符
            • 8.4、逻辑运算符
            • 8.5、三元运算符
            • 九、条件判断语句
            • • 9.1、if语句
              • 9.2、switch语句

                一、java中的第一个程序

                注意：

                1、类定义格式：权限修饰符 class 类名{}

                2、如果类的权限修饰符是public，则类名和文件名必须一致。

                3、main方法的代码，格式固定

                public static void main是固定的，不要去改变

                4、args：表示从运行前传递过来的参数，目前不需要管

                public class Main {     //定义类、    public static void main(String[] args){        System.out.println("运行成功");    }}

                二、java中注释

                2.1、单行注释

                // 单行注释

                2.2、多行注释

                /*多行注释 */

                2.3、文档注释

                /**    文档注释*/

                三、java跨平台实现原理

                四、标识符、关键字、保留字

                标识符：java对各种变量、方法和类等要素命令时使用的字符序列称为标识符。

                • 凡是自己可以起名字的地方都是标识符
                • 命名规则：
                  • 由字母、下划线、数字组成
                  • 不能以数字开头
                  • 严格区分大小写
                  • 不能是java中的关键字和保留字，但是可以包含
                  • 包名：多单词组成时所有字母都是小写
                  • 类名、接口名：多单词组成时所有单词的首字母大写，XxxYyyZzz：称为驼峰式命名。
                  • 变量名、方法名：多单词组成时，第一个单词首字母小写，第二个单词开始每个字母首字母大写；xxxYyyZzz：称为驼峰式命名。
                  • 常量名：所有字母都大写。多单词时每个单词用下划线连接：XXX_YYY_ZZZ。

                    关键字和保留字如下表格：

                    代码如下：

                    package com.company;public class New {    public static void main(String[] args){        int i=1;//        int 1j=11;  //错误的标识符//        int int=100   //错误的标识符        int hello=6;        System.out.println(i);        System.out.println(hello);    }}

                    五、变量

                    5.1、作用

                    变量是用来保存程序中需要被人为操作的一种有类型的数据，变量的值在程序的执行过程中是可以被修改的。

                    5.2、分类

                    5.2.1、属性：默认会被赋值

                    位置：写在类的{}之中，方法的代码块的{}之外。

                    分类：

                    实例属性：格式：权限修改符 数据类型 属性名 = 属性值

                    类属性：格式：权限修改符 static 数据类型 属性名 = 属性值

                    public class New {//    类的{}之间的位置    String name= "yiyi";   //属性，实例属性    static int money = 1000;  //属性，类属性    static int i2;  //i2属性，会被默认赋值，int的默认值为0    public static void main(String[] args){        int i=1;           //局部变量        int hello=6;        }}

                    5.2.2、局部变量：

                    局部变量在使用前必须要赋值

                    位置：

                    • 1、方法体中，即方法的{}之中
                    • 2、方法形参
                    • 3、代码块中

                      public class New {    public static void main(String[] args){        int i=1;           //局部变量        int hello=6;        System.out.println(i);        System.out.println(hello);        // i1的作用域只在int i1代码的下面到方法结束的位置        int i1=10;   // 局部变量        System.out.println(i1);  //局部变量在使用前必须要赋值        System.out.println(i2);    }}

                      5.2.3、作用域

                      变量的有效范围，不管是什么变量，只在它定义的{}范围内才有效

                      5.2.4、变量的定义

                      变量使用之前必须初始化；

                      局部变量的定义格式：数据类型 变量名=变量值；

                      String name="hello";

                      赋值和初始化可以分开使用

                      int i;  //定义变量i=1;   //初始化

                      i2属性，会被默认赋值，int的默认值为0

                      static int i2;  //i2属性，会被默认赋值，int的默认值为0

                      六、java中数据类型

                      6.1、数据类型：两大类

                      • 基本数据类型
                      • 引用数据类型

                        6.2、基本数据类型：四大类，有8个

                        6.2.1、整型：4个，默认值为0，默认类型为int

                        • byte：占1个字节，有8位，数据范围是-128~127，-2^7~2^7-1

                          • short：占2个字节，16位

                          • int：占4个字节，32位

                          • long：占8个字节，64位，数值后面必须带L或者l

                            • 6.2.2、字符型：有且只有一个，默认为''

                              • char：只能使用单引号包裹，有且只有1个符号（字母、数字、中文），除非是Uncode编码

                                • 6.2.3、浮点型：两大类，默认类型为double，默认值为0.0

                                  • float：单精度，4个字节，数值后面必须带F或者f
                                  • double：双精度，8个字节

                                    • 6.2.4、布尔型：只有1个

                                      • boolean：只有false和true

                                        • 6.2.5、从小到大的顺序

                                          byte、short、char、int、long、float、double

                                          boolean不参与排序和类型转换

                                          6.3、引用数据类型：三大类，无数个，默认值都为null

                                          • 类：使用class关键字定义的，例如String
                                          • 数组：使用[]标识
                                            • 接口：使用interface关键字定义的

                                              七、基本数据类型的运算规则

                                              1、byte、short、char三者之间的运算结果数据类型为int。

                                              2、多个不同类型的基本数据类型混合运算以其中数据范围最大的做为返回结果的类型。

                                              八、运算符

                                              8.1、算术运算符

                                              注意：字符串相加时，就是拼接，

                                              1+2+“a”+3；结果为3a3

                                              字符串与其他类型做+，都是以字符串为结果。

                                              public class New {    String name="hello";    public static void main(String[] args){        System.out.println(3+4+"hello!");   //7hello!        System.out.println("hello!"+3+4);   //hello!34        System.out.println("a"+1+"hello!"); //a1hello!        System.out.println("hello"+"a"+1);  //helloa1    }}

                                              public class New {    String name="hello";    public static void main(String[] args){        int i1=10,i2=20;        int i=i1++;        System.out.println("i="+i);   //i=10        System.out.println("i1="+i1);  //i1=11        i=++i1;        System.out.println("i="+i);  //i=12        System.out.println("i1="+i1); //i=12        i=--i1;        System.out.println("i="+i);  //i=11        System.out.println("i1="+i1);  //i=11        i=i1--;         System.out.println("i="+i);  //i=11        System.out.println("i1="+i1); //i=10    }}

                                              8.2、赋值运算符

                                              public class New {    public static void main(String[] args) {        byte b = 1;  //一定是先有定义b变量，才能在下面使用赋值运算符        b += 1;  //值等效于b=(byte)(b+1)        System.out.println(b);    }}

                                              8.3、比较运算符

                                              instanceof：检查对象是否是某个类的对象；

                                              例子：“hello” instanceof String true

                                              //比较运算符public class New {    public static void main(String[] args) {        System.out.println(4==3);  //false        int i1=6;        byte i2=6;        System.out.println(i1==i2);  //true        System.out.println("qwe" instanceof String);  //true    }}

                                              8.4、逻辑运算符

                                              逻辑运算符最终结果都是boolean类型

                                              &：逻辑与；从左到右，不管前面是否已经有了false了，最终结果为false。

                                              |：逻辑或；从左到右，只要有true，那么最终结果为true

                                              &&：短路与；从左到右，只要遇到了false，那么结果为false，后面的表达式就不用执行了。

                                              ||：短路或

                                              ！：逻辑非，取反

                                              ^：逻辑异或；不一样则为true。一样为false

                                              8.5、三元运算符

                                              条件表达式?表达式1:表达式2

                                              public class New {    public static void main(String[] args) {        int a2=10;        int a1=a2>=10 ? a2*2 : a2;        System.out.println(a1);    //20        int score=10;        System.out.println(score==100 ? "奖励1000" : score>=60 ? "及格":"不及格，被打一顿");    }}

                                              九、条件判断语句

                                              9.1、if语句

                                              package com.company;import java.util.Scanner;   //导入类public class ConditionDemo {    public static void main(String[] args){        int score=90;        if(score==100){            System.out.println("奖励1000");        }else if(score>=60){            System.out.println("及格");        }else{            System.out.println("不及格");        }        // Scanner:java提供控制台扫描类        // System.in:内容输入        Scanner sc =new Scanner(System.in);        score=sc.nextInt();   //从控制台输入1个数字        if(score==100){            System.out.println("奖励1000");        }else if(score>=80 && score            System.out.println("奖励100");        }else if(score=60 && score            System.out.println("奖励10");        }else{            System.out.println("奖励0");        }    }}    public static void main(String[] args){        char c='f';        switch (c){            case 'a':                System.out.println("A");                break;            case 'b':                System.out.println("B");                break;            case 'c':                System.out.println("C");                break;            default:                System.out.println("default");                break;        }    }}    public static void main(String[] args){        Scanner sc =new Scanner(System.in);        System.out.println("请输入2024年月份");        System.out.println("请输入2024年天数");        int month=sc.nextInt();   //从控制台输入1个数字        int day=sc.nextInt();   //从控制台输入1个数字        switch (month){            case 12:                day+=31;            case 11:                day+=30;            case 10:                day+=31;            case 9:                day+=30;            case 8:                day+=31;            case 7:                day+=31;            case 6:                day+=30;            case 5:                day+=31;            case 4:                day+=30;            case 3:                day+=31;            case 2:                day+=31;            case 1:                System.out.println(day);        }    }}