标签：02 JAVA 变量 jJAVA int System println public out

一. 符号及类型

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的数据类型分为两大类：
- 基本数据类型：包括整数、浮点数、字符、布尔。
- 引用数据类型：包括类、数组、接口。
基本数据类型
四类八种基本数据类型：

数据类型	关键字	内存占用	取值范围
字节型	byte	1个字节	-128~127
短整型	short	2个字节	-32768~32767
整型	int（默认）	4个字节	-2^31~2的31-1
长整型	long	8个字节	-2^63~2的63-1
单精度浮点数	float	4个字节	1.4013E-45~3.4028E+38
双精度浮点数	double（默认）	8个字节	4.9E-324~1.7977E+308
字符型	char	2个字节	0-65535
布尔类型	boolean	1个字节	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.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.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(){}
    }
}

四. 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 的区别：

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

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

<center>public > protected > (default) > private</center>
访问控制 ：

修饰符	当前类	同一包内	子孙类(同一包)	子孙类(不同包)	其他包
`public`	Y	Y	Y	Y	Y
`protected`	Y	Y	Y	Y/N*	N
`default`	Y	Y	Y	N	N
`private`	Y	N	N	N	N

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

六. 关键字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;
    }
}

标签：02,JAVA,变量,jJAVA,int,System,println,public,out
From： https://www.cnblogs.com/xfbk/p/16916526.html

【JAVA笔记】jJAVA入门基础02

一. 符号及类型

1.1 添加注释comment

1.2 关键字keywords

1.3 标识符

1.4 常量

1.5 变量和数据类型

1.6 数据类型的转换

1.7 ASCII编码表

二. 运算符

2.1 算数运算符

2.2 赋值运算符

2.3 比较运算符

2.4 逻辑运算符

2.5 三元运算符

2.6 常量和变量的运算

三. 方法的入门学习

3.1 方法的定义

3.2 方法的调用

3.3 注意事项

四. 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 几种循环语句的区别：

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

六. 关键字final

6.1 final 修饰类

6.2 final 修饰方法

6.3 final 修饰局部变量

6.4 final 修饰成员变量

相关文章

赞助商

阅读排行

【JAVA笔记】jJAVA入门基础02

一. 符号及类型

1.1 添加注释comment

1.2 关键字keywords

1.3 标识符

1.4 常量

1.5 变量和数据类型

1.6 数据类型的转换

1.7 ASCII编码表

二. 运算符

2.1 算数运算符

2.2 赋值运算符

2.3 比较运算符

2.4 逻辑运算符

2.5 三元运算符

2.6 常量和变量的运算

三. 方法的入门学习

3.1 方法的定义

3.2 方法的调用

3.3 注意事项

四. 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 几种循环语句的区别：

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

六. 关键字final

6.1 final 修饰类

6.2 final 修饰方法

6.3 final 修饰局部变量

6.4 final 修饰成员变量

相关文章

赞助商

阅读排行

4.3 判断语句 `switch`

4.4.1 `for` 循环

4.4.2 `while`循环：

4.4.3 `do - while`循环：