IDEA快捷输入

快捷键	原命令
sout	System.out.println();
psvm	public static void main(String[] args) { }
5.fori	for (int i = 0; i < 5; i++) { }
5.forr	for (int i = 5; i > 0; i—) { }
`shift` + F6	批量替换
数组名称.fori	for (int i = 0; i < 数组名称.length; i++) { }
`alt`+`insert`	快速生成代码（里面包含一些常用的代码块可以直接插入使用）例如Getter/Setter方法和构造方法。
`alt`+`Enter`	快速纠错
set.for	增强for循环

JAVA与Python不同点

单引号引起来的是字符，双引号引起来的是字符串
‘中’ 是字符
“中国”是字符串
‘中国’写法是错误的
布尔常量：true；false
JAVA对于任意变量的使用必须先声明数据类型进行定义，才能进行使用，并且一个变量名只能声明一次。
变量一经初始化就会有初始值。不同的数据类型具有不同的默认值。

数据类型	默认值
整数类型	0
浮点类型	0.0
字符类型	‘\u0000’
布尔类型	false
引用类型	null

类的实例化必须使用关键字new。
整数型数据默认类型为int型；浮点型数据默认为double类型

使用变量的注意事项

如果创建多个变量，那么变量之间的名称不可以重复。
对于float和long类型来说，字母后缀F和L不要丢掉。
如果使用byte或者short类型的变量，那么右侧的数据值不能超过左侧类型的范围。
没有进行赋值的变量，不能直接使用；一定要赋值后才能使用
变量的使用不能超过作用域的范围。

【作用域】：从定义变量的一行开始，一直到直接所属的大括号结束为止。
可以通过一个语句创建多个变量，但是一般情况不推荐这么写。

JAVA中的基本数据类型

4小类8大类

整数型：从小到大依次为byte,short,int,long

浮点型：从小到大依次为float,double

字符型：char

布尔型：boolean
占空间大小排序

最小数据类型：boolean

常用排序： byte<short<int<long<float<double,

char<int<long<float<double, （但是无法与byte和short比较，char无负值）

数据类型转换

在JAVA中，要进行相关的数学运算，必须要求是相同的数据类型。当数据类型不一致时将会发生数据类型转换。

常见的数据类型转换有以下两种：

自动数据类型转换（隐式）：
1. 特点：代码不需要进行特殊处理，自动完成
2. 规则：数据返回从小到大
强制类型转换（显式）
- 特点：代码需要进行特殊的格式处理，不能自动完成。
- 格式：范围小的类型范围小的变量名 = （范围小的类型）原本范围大的数据；
- 注意事项：强制类型转换一般不推荐使用，因为有可能发生精度损失，数据溢出。
- byte/short/char 这三种类型都可以发生数学运算，例如加法”+”。byte/short/char 这三种类型再运算的时候，都会被首先提升成为int类型，然后再计算。
- boolean类型不能发生数据类型转换

package com.tipdm.day01;

public class Demo4{
	public static void main(String[] args){
		System.out.println(1024);   // 这就是一个整数，默认就是int类型
		System.out.println(3.14);  //这就是一个浮点数，默认就是double类型

		// 左边是long类型，右边是默认的int类型，左右不一样
		// 一个等号代表赋值，将右侧的int常量，交给左侧的long变量进行存储
		// int  -->  long，符合了数据范围从小到大的要求
		// 这一行代码发生了自动类型转换。
		long num1 = 100;
		System.out.println(num1);


		// 左边是double类型，右边是float类型，左右不一样
		// float --> double，符合从小到大的规则
		// 也发生了自动类型转换
		double num2 = 2.5F;
		System.out.println(num2);

		// 左边是float类型，右边是long类型，左右不一样
		// long-->float，范围是float更大一些，符合从小到大的规则
		// 也发生了自动类型转换
		float num3 = 30L;
		System.out.println(num3);

		System.out.println("=================================");
		// int n1 = 1L;  // 大范围数据强制转换为小范围数据会造成数据损失，无法发生自动类型转换，报错！
		int n1 = (int)128L;
		System.out.println(n1);

		// int类型强制转换为byte
		// 200本来就超过了byte范围，发送数据溢出，精度损失
		byte n2 = (byte) 200;
		System.out.println(n2);  // -56  发生数据溢出，导致结果不准确

		// double --> int
		int n3 = (int) 3.99999;
		System.out.println(n3); // 并不是四舍五入，所有小数位都会被舍弃掉

		char zifu1 = 'A'; // 这是一个字符型变量，里面是大写字母A
		System.out.println(zifu1 + 1);  // 66, 也就是大写字符A被当作65进行处理
		// 计算机的底层会用一个数字（二进制）来代表字符A，就是65
		// 一旦char类型进行了数学运算，那么字符就会按照一定的规则翻译称为一个数字

		byte num4 = 40;
		byte num5 = 50;
		// byte + byte --> int + int --> int
		// byte result1 = num4 + num5; // 从int转换到byte可能会有损失
		int result1 = num4 + num5;
		System.out.println(result1);

		short num6 = 60;
		// byte + short --> int + int --> int
		int result2 = num4 + num6;
		// int 强制转换为short:注意必须保证逻辑上真实大小本来就没有超过short范围，否则会发生数据溢出
		short result3 = (short)(num5 + num6);
		System.out.println(result2);
		System.out.println(result3);
//		System.out.println((short) 300000);  // -27680  发生数据溢出，导致结果不准确
	}
}

1024
3.14
100
2.5
30.0
=================================
128
-56
3
66
90
100
110

进程已结束,退出代码0

对于byte/short/char三种类型来说，如果右侧赋值的数值没有超过范围，
那么javac编译器将会自动隐含地为我们补上一个(byte)(short)(char)。

如果没有超过左侧的范围，编译器补上强转。
如果右侧超过了左侧范围，那么直接编译器报错。

package com.tipdm.day02;

public class demo9 {
	public static void main(String[] args) {
		// 右侧确实是一个int数字，但是没有超过左侧的范围，就是正确的。
		// int --> byte，不是自动类型转换
		byte num1 = /*(byte)*/ 30; // 右侧没有超过左侧的范围
		System.out.println(num1); // 30
		
		// byte num2 = 128; // 右侧超过了左侧的范围
		
		// int --> char，没有超过范围
		// 编译器将会自动补上一个隐含的(char)
		char zifu = /*(char)*/ 65;
		System.out.println(zifu); // A
	}
}

30
A

进程已结束,退出代码0

在给变量进行赋值的时候，如果右侧的表达式当中全都是常量，没有任何变量，
那么编译器javac将会直接将若干个常量表达式计算得到结果。

1	short result = 5 + 8; // 等号右边全都是常量，没有任何变量参与运算

编译之后，得到的.class字节码文件当中相当于【直接就是】：

右侧的常量结果数值，没有超过左侧范围，所以正确。

这称为“编译器的常量优化”。

但是注意：一旦表达式当中有变量参与，那么就不能进行这种优化了。

package com.tipdm.day02;

public class demo10{
	public static void main(String[] args) {
		short num1 = 10; // 正确写法，右侧没有超过左侧的范围，
		
		short a = 5;
		short b = 8;
		// short + short --> int + int --> int
        // 出现数据范围大 -> 数据范围小，无法发生自动类型转换
		// short result = a + b; // 错误写法！左侧需要是int类型
		
		// 右侧不用变量，而是采用常量，而且只有两个常量，没有别人
		short result = 5 + 8;
		System.out.println(result);
		
		// short result2 = 5 + a + 8; // 18
	}
}

字符与数字对照关系表

数字和字符的对照关系表（编码表）：

ASCII码表：American Standard Code for Information Interchange，美国信息交换标准代码。
Unicode码表：万国码。也是数字和负号的对照关系表，开头0-127部分和ASCII完全一样，但是从128开始包含有更多字符。

48 - ‘0’
65 - ‘A’
97 - ‘a’
*/

package com.tipdm.day01;

public class Demo5{
	public static void main(String[] args){
		char zifu='1';
		System.out.println(zifu + 1);
		
		char zifu2 = 'A';  // 其实底层保存的是65数字
		
		char zifu3 = '中';
		// 左侧是int类型，右边是char类型
		// char --> int 确实是从小到大
		// 发生了自动类型转换
		int num = zifu3;
		System.out.println(num);
		
		char zifu4 = '中';
		System.out.println(zifu4+1);
	}
}


50
20013
20014

进程已结束,退出代码0

Java中的数学运算符及表达式

四则运算符

运算符：进行特定操作的符号。例如：+，-，*，/
表达式：用运算符连起来的式子叫做表达式。例如：20+5。又例如：a + b

四则运算，首先计算得到表达式的结果，然后再打印输出这个结果。

复习一下小学一年级的除法公式：

被除数/ 除数=商… 余数

对于一个整数的表达式来说，除法用的是整除，整数除以整数，结果仍然是整数。只看商，不看余数。

只有对于整数的除法来说，取模运算符才有余数意义

注意事项：

一旦运算当中有不同类型的数据，那么结果将会是数据类型范围大的那种。

package com.tipdm.day02;

public class demo1 {
    public static void main(String[] args) {
        // 两个常量之间可以进行数学运算
        System.out.println(20+30);  // 50

        // 两个变量之间也可以进行数学运算
        int a = 20;
        int b = 30;
        System.out.println(a + b);  // 50

        // 常量和变量之间可以混合使用
        System.out.println(a * 10);  // 200

        int x = 10;
        int y = 3;

        int result1 = x / y;
        System.out.println(result1);  // 3  只看商不看余数

        int result2 = x % y;
        System.out.println(result2);  // 1  余数，模。

        // int + double --> double + double --> double
        double result3 = x + 2.5;
        System.out.println(result3);
    }

}

50
50
200
3
1
12.5

进程已结束,退出代码0

四则运算当中的加号”+“有常见的三种用法：

对于数值来说，那就是加法。
对于字符char类型来说，在计算之前，char会被提升成为int，然后再计算。char类型字符，和int类型数字，之间的对照关系表：ASCII，Unicode
对于字符串String（首字母大写，并不是关键字）来说，加号代表字符串连接操作。

任何数据类型和字符串进行连接的时候，结果都会变成字符串。

package com.tipdm.day02;

public class demo2 {
    public static void main(String[] args) {
        // 数据类型 变量名称 = 数据值;
        String str1 = "你好";
        System.out.println(str1);
        System.out.println("Hello" + ",World!");  // 连接字符串

        String str2 = "Java";
        // String + int --> String
        System.out.println(str2 + 20);

        // 优先级问题
        // String + int + int
        //      String  + int
        //      String
        System.out.println(str2 + 20 + 30);  // Java2030
        // int + int + String
        //     int   + String
        //      String
        System.out.println(20 + 30 + str2);  // 50Java
        System.out.println(str2 + (20 + 30));  // 括号可改变优先级
    }
}

你好
Hello,World!
Java20
Java2030
50Java
Java50

进程已结束,退出代码0

自增、自减运算符

自增运算符：++

自减运算符：—

基本含义：让一个变量涨一个数字1，或者让一个变量降一个数字1

使用格式：写在变量名称之前，或者写在变量名称之后。例如：++num，也可以num++

使用方式：

单独使用：不和其他任何操作混合，自己独立称为一个步骤
混合使用：和其他操作混合，例如与赋值混合，或者与打印操作混合，等。

使用区别：

在单独使用时，++num和num++没有任何区别
在混合使用时，有【重大区别】
- 如果是num++，表示先使用num值参与运算，再自加
- 如果是++num，表示先自加，再参与运算

—使用方式和++同理

注意事项：只有变量才能使用自增，自减运算符。常量不可发生改变，所以不能用。

package com.tipdm.day02;

public class demo3 {
    public static void main(String[] args) {
        int num1 = 10;
        num1++;
        System.out.println(num1);  // 11
        ++num1;
        System.out.println(num1);  // 12
        System.out.println(num1++);  // 12
        System.out.println(num1);  // 13
        System.out.println(++num1);  // 14

        // 30++;  // 错误写法！常量不可以使用++或--
    }
}

11
12
12
13
14

进程已结束,退出代码0

赋值运算符

赋值运算符分为

基本赋值运算符：就是一个等号”=“，代表将右侧的数据交给左侧的变量。

int a = 30;

复合赋值运算符：

+= a += 1 ==> a = a + 1

-= b -= 4 ==> b = b - 4

*=

/=

%=

注意事项：

只有变量才能使用赋值运算符，常量不能进行赋值
复合赋值运算符其中隐含了一个强制类型转换

package com.tipdm.day02;

public class demo4 {
    public static void main(String[] args) {
        int a = 10;
        // 按照公式进行翻译：a = a + 5
        // a = 10 + 15
        // a = 15
        a += 5;
        System.out.println(a);

        int x = 10;
        x %= 3;
        System.out.println(x);

        byte y = 30;
        // y += 5;
        // y = y + 5
        // byte + int
        // int + int
        // (byte) (int + int)
        y += 5;
        System.out.println(y);
    }
}

15
1
35

进程已结束,退出代码0

比较运算符

比较运算符：

大于: >
小于: <
大于等于: >=
小于等于: <=
相等: == 【两个等号连写才是相等，一个等号代表的是赋值】
不相等: !=

注意事项：

比较运算符的结果一定是一个boolean值，成立就是true，不成立就是false

如果进行多次判断，不能连着写

数学当中的写法，例如：1 < x < 3

程序当中【不允许】这种写法

package com.tipdm.day02;

public class demo5 {
    public static void main(String[] args) {
        System.out.println(10 > 5);  // true
        int num1 = 10;
        int num2 = 20;
        System.out.println(num1 < num2);  // true
        System.out.println(num2 >= 100);  // false
        System.out.println(num2 <= 100);  // true
        System.out.println(num2 <= 12);  // true
        System.out.println("=======================");
        System.out.println(10 == 10);  // true
        System.out.println(20 != 25);  // true
        System.out.println(20 != 20);  //false

        int x = 2;
        // System.out.println(1 < x < 3);  // 错误写法，不能连着写
    }
}

true
true
false
true
false
=======================
true
true
false

进程已结束,退出代码0

逻辑运算符

与（并且） && 全都是true才是true；否则就是false
或（或者） || 全都是false才是false；否则就是true
非（取反）！是ture返回false；是false返回true

与”&&“, 或”||” 的短路效应

注意事项：

逻辑运算符只能用于boolean值。
与、或需要左右各自有一个boolean值，但是取反只要有唯一的一个boolean值即可。
与、或两种运算符，如果有多个条件，可以连续写。

两个条件：条件A && 条件B

多个条件：条件A && 条件B && 条件C

对于1 < x < 3的情况，应该拆成两个部分，然后使用与运算符连接起来：

int x = 2;

1 < x && x < 3

package com.tipdm.day02;

public class demo6 {
    public static void main(String[] args) {
        System.out.println(true && false);
        System.out.println(true && true);
        System.out.println(false || true);
        System.out.println(!(false || true));
        System.out.println("============================");
        int a = 50;

        System.out.println(a > 30 && a != 90);   //   a大于30且不为90
        System.out.println("============================");
        int b = 10;
        System.out.println(3>4 &&  ++b < 100);  // flase  && ...
        System.out.println(b);  // 说明++b代码并没有运行
    }
}

false
true
true
false
============================
true
============================
false
10

进程已结束,退出代码0

三元运算符

一元运算符：只需要一个数据可以进行操作的运算符。例如：取反！、自增++、自减—
二元运算符：需要两个数据才可以进行操作的运算符。例如：加法+、减法-、赋值=
三元运算符：需要三个数据才可以进行操作的运算符。
格式：数据类型变量名称 = 条件判断 ? 表达式A : 表达式B

流程：

首先判断条件是否成立：

如果成立为true，那么将表达式A的值赋值给左侧的变量

如果不成立为false，那么将表达式B的值赋值给左侧的变量

二者选其一

注意事项：

必须同时保证表达式A和表达式B都符合左侧数据类型的要求。
三元运算符的结果必须被使用。

package com.tipdm.day02;

public class demo7 {
    public static void main(String[] args) {
        int a = 10;
        int b = 20;

        int max = a > b ? a : b;
        System.out.println(max);

        int res = (int)(3 > 4 ? 2.5 : 10);  // 数据类型可能从double变为了int，发生数据损失，虽然这里明显res应该取值为10
        System.out.println(res);

        System.out.println(a > b ? a : b);

//        a > b ? a : b; // 错误写法，三元运算符的结果必须使用，要么输出，要么赋值
    }
}

20
10
20

进程已结束,退出代码0

Java方法

定义一个方法的格式：

1
2
3

public static void 方法名称() {
    方法体
}

方法名称的命名规则和变量一样，使用小驼峰。
方法体：也就是大括号当中可以包含任意条语句。

注意事项：

方法定义的先后顺序无所谓。
方法的定义不能产生嵌套包含关系。
方法定义好了之后，不会执行的。如果要想执行，一定要进行方法的【调用】。

如何调用方法，格式：

方法名称();

package com.tipdm.day02;

public class demo8 {

    public static void main(String[] args) {
        farmer(); // 调用农民的方法
        seller(); // 调用小商贩的方法
        cook(); // 调用厨子的方法
        me(); // 调用我自己的方法
    }

    // 厨子
    public static void cook() {
        System.out.println("洗菜");
        System.out.println("切菜");
        System.out.println("炒菜");
        System.out.println("装盘");
    }

    // 我
    public static void me() {
        System.out.println("吃");
    }

    // 小商贩
    public static void seller() {
        System.out.println("运输到农贸市场");
        System.out.println("抬高价格");
        System.out.println("吆喝");
        System.out.println("卖给厨子");
    }

    // 农民伯伯
    public static void farmer() {
        System.out.println("播种");
        System.out.println("浇水");
        System.out.println("施肥");
        System.out.println("除虫");
        System.out.println("收割");
        System.out.println("卖给小商贩");
    }
}

播种
浇水
施肥
除虫
收割
卖给小商贩
运输到农贸市场
抬高价格
吆喝
卖给厨子
洗菜
切菜
炒菜
装盘
吃

进程已结束,退出代码0

Ming-Log's Blog

Java(1)编程基础

IDEA快捷输入

JAVA与Python不同点

使用变量的注意事项

JAVA中的基本数据类型

数据类型转换

字符与数字对照关系表

Java中的数学运算符及表达式

四则运算符

自增、自减运算符

赋值运算符

比较运算符

逻辑运算符

三元运算符

Java方法