JAVA学习笔记_入门基础

参考链接： 在Java中使用_(下划线)作为变量名

文章目录

 JAVA学习笔记_入门基础1. 符号及类型1.1 添加注释comment1.2 关键字keywords1.3 标识符1.4 常量1.5 变量和数据类型1.6 数据类型的转换1.7 ASCII编码表

   在这里插入图片描述

  2. 运算符2.1 算数运算符2.2 赋值运算符2.3 比较运算符2.4 逻辑运算符2.5 三元运算符2.6 常量和变量的运算

  3. 方法的入门学习3.1 方法的定义3.2 方法的调用3.3 注意事项

  4. java中的流程控制语句4.1 顺序结构4.2 判断语句4.3 判断语句 `switch`4.4 循环语句4.4.1 `for` 循环4.4.2 `while`循环：4.4.3 `do - while`循环：4.4.4 几种循环语句的区别：

  5. Java 中的四种权限修饰符6. 关键字final6.1 final 修饰类6.2 final 修饰方法6.3 final 修饰局部变量6.4 final 修饰成员变量

JAVA学习笔记_入门基础 

1. 符号及类型 

1.1 添加注释comment 

注释：就是对代码的解释和说明。其目的是让人们能够更加轻松地了解代码。为代码添加注释，是十分必须要的，它不影响程序的编译和运行。Java中有单行注释和多行注释 

  单行注释以 //开头 换行结束多行注释以 /*开头 以*/结束  

1.2 关键字keywords 

关键字 : 是指在程序中，Java已经定义好的单词，具有特殊含义。出现的关键字有 public 、 class 、 static 、void 等，这些单词已经被 Java定义好，全部都是小写字母，notepad++中颜色特殊。关键字比较多，不能死记硬背，学到哪里记到哪里即可。 

1.3 标识符 

 标识符：是指在程序中，我们自己定义内容。比如类的名字、方法的名字和变量的名字等等，都是标识符。  命名规则： 硬性要求 

  标识符可以包含 英文字母26个(区分大小写) 、 0-9数字 、 $（美元符号） 和 _（下划线） 。标识符不能以数字开头。标识符不能是关键字。  命名规范： （建议）  类名规范：首字母大写，后面每个单词首字母大写（大驼峰式）。HelleWorld  方法名规范： 首字母小写，后面每个单词首字母大写（小驼峰式）helleWorld  变量名规范：全部小写。  

1.4 常量 

分类 

类型含义数据举例整数常量所有的整数0，1， 567， -9小数常量所有的小数0.0， -0.1， 2.55字符常量单引号引起来,只能写一个字符,必须有内容‘a’ ， ’ '， ‘好’字符串常量双引号引起来,可以写多个字符,也可以不写“A” ，“Hello” ，“你好” ，“ ”布尔常量只有两个值（流程控制中讲解）true ， false空常量只有一个值（引用数据类型中讲解）null

public class DemoConst{

    public static void main(String[] args){

        //输出整数常量

        System.out.println(123);

        //输出小数常量

        System.out.println(0.125);

        //输出字符常量

        System.out.println('A'); // 单引号里面有且只有一个字符

        //输出布尔常量

        System.out.println(true);

        //输出字符串常量

        System.out.println("你好Java");

        //空常量不能直接输出

    }

}

1.5 变量和数据类型 

 变量：常量是固定不变的数据，那么在程序中可以变化的量称为变量。 Java中要求一个变量每次只能保存一个数据，必须要明确保存的数据类型。  数据类型： 

  Java的数据类型分为两大类：基本数据类型：包括 整数 、 浮点数 、 字符 、 布尔 。引用数据类型：包括 类 、 数组 、 接口 。  基本数据类型 四类八种基本数据类型：  

数据类型关键字内存占用取值范围字节型byte1个字节-128~127短整型short2个字节-32768~32767整型int（默认）4个字节-231~2的31-1长整型long8个字节-263~2的63-1单精度浮点数float4个字节1.4013E-45~3.4028E+38双精度浮点数double（默认）8个字节4.9E-324~1.7977E+308字符型char2个字节0-65535布尔类型boolean1个字节true，false字符串String––

格式 

数据类型 变量名 = 数据值;

实列代码： 

public class Variable {

    public static void main(String[] args){

        //定义字节型变量

        byte b = 100;

        System.out.println(b);

        //定义短整型变量

        short s = 1000;

        System.out.println(s);

        //定义整型变量

        int i = 123456;

        System.out.println(i);

        //定义长整型变量

        long l = 12345678900L;

        System.out.println(l);

        //定义单精度浮点型变量

        float f = 5.5F;

        System.out.println(f);

        //定义双精度浮点型变量

        double d = 8.5;

        System.out.println(d);

        //定义布尔型变量

        boolean bool = false;

        System.out.println(bool);

        //定义字符型变量

        char c = 'A';

        System.out.println(c);

    }

}

 long类型：建议数据后加L表示。 float类型：建议数据后加F表示 。 

1.6 数据类型的转换 

 自动转换 实列： 一个 int 类型变量和一个 byte 类型变量进行加法运算， 结果会是什么数据类型？ public static void main(String[] args) {

    int i = 1;

    byte b = 2;

    // byte x = b + i; // 报错

    //int类型和byte类型运算，结果是int类型

    int j = b + i;

    System.out.println(j);

}

 运算结果，变量的类型将是 int 类型，这就是出现了数据类型的自动类型转换现象。 自动转换：将类型自动提升为 取值范围大的类型 。 byte、short、char ‐‐> int ‐‐> long ‐‐> float ‐‐> double

  强制转换 数据类型 变量名 = （数据类型）被转数据值；

 实列： public static void main(String[] args) {

    //short类型变量，内存中2个字节

    short s = 1;

    /*

    出现编译失败

    s和1做运算的时候，1是int类型，s会被提升为int类型

    s+1后的结果是int类型，将结果在赋值会short类型时发生错误

    short内存2个字节，int类型4个字节

    必须将int强制转成short才能完成赋值

    */

    s = s + 1；//编译失败

    s = (short)(s+1);//编译成功

}

1.7 ASCII编码表 

在计算机的内部都是二进制的0、1数据，如何让计算机可以直接识别人类文字的问题呢？就产生出了编码表的概念。 

编码表：就是将人类的文字和一个十进制数进行对应起来组成一张表格。 

2. 运算符 

2.1 算数运算符 

算数运算符+加法运算，字符串连接运算-减法运算*乘法运算/除法运算（对于整数的除法，这里是整除）%取模运算，两个数字相除取余数（只对整数有用）++ 、 –自增自减运算

 ++ 运算，变量自己增长1。反之， -- 运算，变量自己减少1，用法与 ++ 一致。 

   独立运算： 

    变量在独立运算时， 前++ 和 后++ 没有区别 。变量 前++ ：例如 ++i 。变量 后++ ：例如 i++ 。  混合运算：  和其他变量放在一起， 前++ 和 后++ 就产生了不同。  变量 前++ ：变量a自己加1，将加1后的结果赋值 给b，也就是说a先计算。a和b的结果都是2 public static void main(String[] args) {

    int a = 1;

    int b = ++a;

    System.out.println(a);//计算结果是2

    System.out.println(b);//计算结果是2

}

  变量 后++ ：变量a先把自己的值1，赋值给变量b，此时变量b的值就是1，变量a自己再加1。a的结果是2，b的结果是1。  ```java

public static void main(String[] args) {

    int a = 1;

    int b = a++;

    System.out.println(a);//计算结果是2

    System.out.println(b);//计算结果是1

}

```

  +符号在字符串中的操作： + 符号在遇到字符串的时候，表示连接、拼接的含义。 "a"+"b"的结果是“ab”，连接含义  

public static void main(String[] args){

    System.out.println("5+5="+5+5);//输出5+5=55

}

2.2 赋值运算符 

赋值运算符包括：=等于号+=加等于-=减等于*=乘等于/=除等于%=取模等

public static void main(String[] args){

    short s;

    s = s + 1 ; // 错误,因为 s+1 会转化为int类型，再赋值给short类型的s，则会出错。

    short s = 1;

    s+=1; // 正确，等同于s = short(s+1);

    System.out.println(s);

}

 分析： s += 1 逻辑上看作是 s = s + 1 计算结果被提升为int类型，再向short类型赋值时发生错误，因为不能将取值范围 大的类型赋值到取值范围小的类型。但是， s=s+1进行两次运算 ， += 是一个运算符，只运算一次，并带有强制转换的特点， 也就是说 s += 1 就是 s = (short)(s+1) ，因此程序没有问题编译通过，运行结果是2. 

2.3 比较运算符 

比较运算符包括：==比较符号两边数据是否相等，相等结果是true。<比较符号左边的数据是否小于右边的数据，如果小于结果是true。>比较符号左边的数据是否大于右边的数据，如果大于结果是true。<=比较符号左边的数据是否小于或者等于右边的数据，如果小于结果是true。>=比较符号左边的数据是否大于或者等于右边的数据，如果小于结果是true。!=不等于符号 ，如果符号两边的数据不相等，结果是true。

2.4 逻辑运算符 

逻辑运算符包括：&& 且1. 两边都是true，结果是true 2. 一边是false，结果是false 短路特点：符号左边是false，右边不再运算|| 或1. 两边都是false，结果是false 2. 一边是true，结果是true 短路特点： 符号左边是true，右边不再运算！ 非1. ! true 结果是false 2. ! false结果是true

注 ： 逻辑运算符，是用来连接两个布尔类型结果的运算符，运算结果都是布尔值 true 或者 false 

2.5 三元运算符 

 三元运算符格式： 数据类型 变量名 = 布尔类型表达式？结果1：结果2

  布尔类型表达式结果是true，三元运算符整体结果为结果1，赋值给变量。布尔类型表达式结果是false，三元运算符整体结果为结果2，赋值给变量。  

实列 ： 

public static void main(String[] args) {

    // 比较运算符

    System.out.println(1==1);//true

    System.out.println(1<2);//true

    System.out.println(3>4);//false

    System.out.println(3<=4);//true

    System.out.println(3>=4);//false

    System.out.println(3!=4);//true

    // 逻辑运算符

    System.out.println(true && true);//true

    System.out.println(true && false);//false

    System.out.println(false && true);//false

    System.out.println(false || false);//falase

    System.out.println(false || true);//true

    System.out.println(true || false);//true 

    System.out.println(!false); //true

    int i = (1==2 ? 100 : 200);

    System.out.println(i);//200

    int j = (3<=4 ? 500 : 600);

    System.out.println(j);//500

}

2.6 常量和变量的运算 

public static void main(String[] args){

    byte b1=1;

    byte b2=2;

    byte b3=1 + 2; //正确

    byte b4=b1 + b2; //错误

    System.out.println(b3);

    System.out.println(b4);

}

 分析： b3 = 1 + 2 ， 1 和 2 是常量，为固定不变的数据，在编译的时候, 已经确定了 1+2 的结果并没有超过byte类型的取值范围，可以赋值给变量 b3 ，因此 b3=1 + 2 是正确的。 反之， b4 = b2 + b3 ， b2 和 b3 是变量，变量的值是可能变化的，在编译的时候，编译器javac不确定b2+b3的结果是什么，因此会将结果以int类型进行处理，所以int类型不能赋值给byte类型，因此编译失败。 

3. 方法的入门学习 

方法：就是将一个功能抽取出来，把代码单独定义在一个大括号内，形成一个单独的功能。当我们需要这个功能的时候，就可以去调用。这样即实现了代码的复用性，也解决了代码冗余的现象。 

3.1 方法的定义 

定义格式： 

修饰符 返回值类型 方法名 （参数列表）｛

    代码...

    return ;

｝

修饰符： public ,default ,private ,protected… 

返回值类型： void , int , double.…方法名：为我们定义的方法起名，满足标识符的规范，用来调用方法。参数列表： 目前无参数， 带有参数的方法在后面的课程讲解。return：方法返回值类型。返回值类型是void，return可以不写。 

public static void methodName() {

    System.out.println("这是一个方法");

}

3.2 方法的调用 

方法在定义完毕后，方法不会自己运行，必须被调用才能执行， 我们可以在主方法main中来调用我们自己定义好的方法。在主方 法(main)中，直接写要调用的方法名字就可以调用了。 

public static void main(String[] args) {

    //调用定义的方法method

    method();

} 

//定义方法，被main方法调用

public static void method() {

    System.out.println("自己定义的方法，需要被main调用运行");

}

3.3 注意事项 

方法必须定义在一个类中的方法外方法不能定义在另一个方法的里面 

public class Demo {

    public static void main(String[] args){} //正确写法，类中，main方法外面可以定义方法

    public static void method(){}

} 

public class Demo {

    public static void main(String[] args){

    //错误写法，一个方法不能定义在另一方法内部

        public static void method(){}

    }

}

4. java中的流程控制语句 

在一个程序执行的过程中，各条语句的执行顺序对程序的结果是有直接影响的。也就是说，程序的流程对运行结果有直接的影响。所以，我们必须清楚每条语句的执行流程。而且，很多时候我们要通过控制语句的执行顺序来实现我们要完成的功能 

4.1 顺序结构 

public static void main(String[] args){

    //顺序执行，根据编写的顺序，从上到下运行

    System.out.println("frist");

    System.out.println("second");

    System.out.println("third");

}

4.2 判断语句 

单 if语句 

public static void main(String[] args){

    System.out.println("判读开始");

    // 定义两个变量

    int a = 10;

    int b = 20;

//变量使用if判断

    if (a == b){

    System.out.println("a==b");

    } 

    int c = 10;

    if(a == c){

    System.out.println("a==c");

    } 

    System.out.println("判断结束");

｝

if - else 语句 

public static void main(String[] args){

    // 判断给定的数据是奇数还是偶数

    // 定义变量

    int a = 1;

    if(a % 2 == 0) {

    System.out.println("a是偶数");

    } else{

    System.out.println("a是奇数");

    } 

    System.out.println("结束");

}

if - else if - else 

public static void main2(String[] args) {

    int score = 100;

    if (score < 0 || score > 100) {

        System.out.println("成绩给定出错");

    } else if (score >= 90 && score <= 100) {

        System.out.println("成绩属于优秀");

    } else if (score >= 80 && score < 90) {

        System.out.println("成绩属于好");

    } else if (score >= 70 && score < 80) {

        System.out.println("成绩属于良");

    } else if (score >= 60 && score < 70) {

        System.out.println("成绩属于及格");

    } else {

        System.out.println("成绩属于不及格");

    }

}

三元运算符和if语句 

public static void main2(String[] args) {

    int a = 10;

    int b = 20;

    //定义变量，保存a和b的较大值

    int c;

    if (a > b) {

        c = a;

    } else {

        c = b;

    }

    //可以上述功能改写为三元运算符形式

    c = a > b ? a : b;

}

4.3 判断语句 switch 

 switch语句格式： switch(表达式) {

    case 常量值1:

        语句体1;

        break;

    case 常量值2:

        语句体2;

        break;

    ...

    default:

        语句体n+1;

        break;

}

  标准的switch语句： public static void main(String[] args) {

        //剪刀石头布游戏

        String chose = "剪刀";

        //switch语句实现选择

        switch(chose) {

            case "剪刀":

                System.out.println("石头");

                break;

            case "石头":

                System.out.println("布");

                break;

            case "布"：

                System.out.println("剪刀")；  

        }

}

  switch 语句中的无break;，将不会理会case public static void main(String[] args) {

  // write your code here

  System.out.println("Hello, Word !!!");

  int i = 5;

  switch (i) {

      case 0:

          System.out.println("执行case0");

          break;

      case 5:

          System.out.println("执行case5");

      case 10:

          System.out.println("执行case10");

      default:

          System.out.println("执行default");

  } 

}

输出：

执行case5

执行case10

执行default

 4.4 循环语句 4.4.1 for 循环 

   使用 for 循环 输出9 * 9 乘法表: public static void main(String[] args) {

    // write your code here

    System.out.println("9 * 9 乘法表");

    for (int i = 1; i <= 9; i++) {

        for (int b = 1; b <= i; b++) {

            System.out.print(b + "X" + i + "=" + b * i + "\t");

        }

        System.out.print("\n");

    }

}

  4.4.2 while循环： 

  使用 while计算1 - 100 的求和： public static void main(String[] args) {

    // write your code here

    System.out.println("Hello, Word !!!");

    int i = 1, sum =0;

    while (i<100){

        sum += i;

        i++;

    }

    System.out.println(sum);

}

 4.4.3 do - while循环： 

  输出十次 JAVA: public static void main(String[] args) {

    int x=1;

    do {

    System.out.println("JAVA");

    x++;

    }while(x<=10);

}

 4.4.4 几种循环语句的区别： 

  for 和 while 的区别： 

  for 循环中控制变量在每次循环结束后，就在内存中消失，说以在一般情况下更加的推荐使用for循环，提高内存的使用效率。在已知循环次数的时候使用推荐使用for，循环次数未知的时推荐使用while。  

5. Java 中的四种权限修饰符 

 public > protected > (default) > private

 **访问控制** ： 

修饰符当前类同一包内子孙类(同一包)子孙类(不同包)其他包publicYYYYYprotectedYYYY/N*NdefaultYYYNNprivateYNNNN

N*: 接口及接口的成员变量和成员方法不能声明为 protected  

6. 关键字final 

 关键字final代表最终、不可改变的。在继承中，子类可以重写父类的方法，为了避免这种随意改写的情况，Java提供了 final 关键字，用于修饰不可改变内容。 

 常见四种用法： 

 可以用来修饰一个类可以用来修饰一个方法还可以用来修饰一个局部变量还可以用来修饰一个成员变量 

6.1 final 修饰类 

 格式： 

 public final class 类名称 {

    // ...

}

 含义：当前这个类不能有任何的子类。 注意：一个类如果是final的，那么其中所有的成员方法都无法进行覆盖重写。 

6.2 final 修饰方法 

 当final关键字用来修饰一个方法的时候，这个方法就是最终方法，也就是不能被覆盖重写。 格式： 

 修饰符 final 返回值类型 方法名称(参数列表) {

    // 方法体

}

 注意事项： 对于类、方法来说，abstract关键字和final关键字不能同时使用，因为矛盾。 

6.3 final 修饰局部变量 

 一旦使用final用来修饰局部变量，那么这个变量就不能进行更改。 

 “一次赋值，终生不变” 

 对于基本类型来说，不可变说的是变量当中的数据不可改变对于引用类型来说，不可变说的是变量当中的地址值不可改变 

6.4 final 修饰成员变量 

 对于成员变量来说，如果使用final关键字修饰，那么这个变量也照样是不可变。 

 因为final修饰的成员变量，赋值后不可修改，所有不允许无参构造方法默认赋值null。对于final的成员变量，要么使用直接赋值，要么通过构造方法赋值。二者选其一。必须保证类当中所有重载的构造方法，都最终会对final的成员变量进行赋值。 

 例如： 

 public class Person {

    // 直接赋值，一旦使用final修饰的成员变量进行了直接赋值，构造方法就不能再对其赋值。

    // private  final String name = "AAA"; 

    // 不使用直接赋值，构造方法必须进行赋值。

    private final String name;

    public Person() {

        name = "AAA";

    }

    public Person(String name) {

        this.name = name;

    }

}