数据运算和方法入门

数据类型的转换

自动类型转换（隐式）

1.特点：不需要对代码进行特殊处理，自动完成。

2.规则：数据范围从小到大。

package Demo01;
/**
 * @author Edwin D
 * @date 2020.4.4 上午 10:42
 */
public class DemoData {
    public static void main(String[] args) {
//        左边是long型，右边是int型，左右不一样，等号将int型赋值给long型，
//        int-->long符合从小到大的规则，可以进行自动类型转换。
        long n1 = 100;
        System.out.println(n1);
//        左边是double型，右边是float型，左右不一样，等号将float型赋值给double型，
//        float-->double符合从小到大的规则，可以进行自动类型转换。
        double n2 = 100F;
        System.out.println(n2);
//        左边是float型，右边是long型，左右不一样，等号将long型赋值给float型，
//       long-->float符合从小到大的规则，可以进行自动类型转换。
        float n3 = 100L;
        System.out.println(n3);

    }
}

强制类型转换

1.特点：代码需要进行特殊格式的处理，不能自动完成。

2.格式：

范围小的类型 范围小的名称 = (范围小的类型) 原本范围大的数据;

3.注意：

1.强制转换一般不推荐使用，因为有可能会产生精度损失和数据溢出。

2.byte/short/char这三种类型都可以发生数学运算，例如加法“+”;

3.byte/short/char这三种类型在运算的时候，都会先被提升成为int类型，然后再计算;

4.boolean类型不能发生数据转换;

package Demo01;
/**
 * @author Edwin D
 * @date 2020.4.4 上午 10:48
 */
public class DemoData2 {
//    左边是int型，右边是long型，左右不一样，等号将long型赋值给int型，
//    long-->int不符合从小到大的规则，不可以进行自动类型转换。
    public static void main(String[] args) {
        int n4 = (int) 100L;
        System.out.println(n4);

//        long型强转int
        int n5 = (int)7777777777L;
        System.out.println(n5);//输出-812156815,数据溢出;

//        double型强转int
        int n6 = (int) 3.5;
        System.out.println(n6);//输出3,精度损失;

        char n7 = 'A';//字符变量A,
        System.out.println(n7+1);//66是大写字母“A”被当做数字65处理后的结果。
        /*计算机会用二进制表示所输入的一切，"A"就是65，
          一旦char类型进行了数字类型的计算，那么字符就会按照一定的规则将它转换成数字。*/

        byte n8 = 7;
        byte n9 = 77;
//        byte + byte --> int + int --> int
        int n0 = n9 + n8;
        System.out.println(n0);

        short n11 = 777;
        short n12 = (short) (n8 + n11);
//        byte + short --> int + int --> int
        System.out.println(n12);
    }
}

ASCII码

American Standard Code for Information Interchange.美国信息交换标准代码。

Unicode码表：万国表，也是数字和符号的对照关系，开头0-127部分和ASCII一样，但是从128开始包含更多的字符。甚至连Emoji都在其中。

特殊：48-0;65-A;97-a;

运算符和表达式

注意：

1.一旦运算中有两个不同类型的数据，那么加过将会是数据范围大的那个类型。

2.对于char类型，在计算之前，会被提升为int，然后再计算。char类型和int类型之间的对应关系按照ASCII和Unicode码。

3.对于String字符串(首字母大写，并且不是关键字)来说，加号代表字符串连接操作。

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

package Demo01;
/**
 * @author Edwin D
 * @date 2020.4.4 下午 12:20
 */
public class DemoData3 {
    public static void main(String[] args) {
        String str1 = "Hello";
        System.out.println(str1);

        String str2 = "World";
        System.out.println(str1 +" "+ str2); //Hello World
//        String + int --> String;
        String str3 = "Cheng";
        System.out.println(str3 + " 果果" +25);//Cheng 果果25
    }
}

自增自减

使用方式：

1.单独使用：不和其他任何操作混合，自己独立成为一个步骤。

2.混合使用：和其他操作混合（eg:与赋值混合，与打印混合……）

++num和num++使用区别:
1.在单独使用的时候，前++和后++没有任何区别。也就是: ++num;和num++;是完全一样的。
2.在混合的时候，有[重大区别]
A.如果是[前++]，那么变量[立刻马上+1]，然后拿着结果进行使用。[先加后用]
B.如果是[后++]，那么首先使用变量本来的数值， [然后再让变量+1]。[先用后加]

（只有变量可以使用，常量无法使用）

赋值运算符

注意事项:
1.只有变量才能使用赋值运算符，常量不能进行赋值。
2.复合赋值运算符其中隐含了一个强制类型转换。

public static void main(){
    byte num = 30;
	//num=num+5;
    //num=byte+int
    //num=int+int
    // num = int
    // num = (byte) int
    num += 5;
    System.out.println(num); // 35
}

比较运算符

注意事项:
1.比较运算符的结果一定是一个boolean值，成立就是true,不成立就是false
2.如果进行多次判断，不能连着写。eg：数学当中的写法，例如:1< x< 3。程序当中[不允许]这种写法。

逻辑运算符

1.与(并且) &全都是true， 才是true; 否则就是false
2.或(或者) II 至少一个是true, 就是true; 全都是false, 才是false
3.(取反) !本来是true, 变成false; 本来是false, 变成true
4.与“&&”，或“||”， 具有短路效果:如果根据左边已经可以判断得到最终结果，那么右边的代码将不再执行，从而节省一定的性能。

注意事项:
1.逻辑运算符只能用于boolean值。
2.与、或需要左右各自有一个boolean值，但是取反只要有唯一的一个boolean值即可。
3.与、或两种运算符，如果有多个条件，可以连续写。
两个条件:条件A && 条件B
多个条件:条件A && 条件B && 条件C
Ps：
对于1 < x < 3的情况，应该拆成两个部分，然后使用与运算符连接起来:
int x = 2; 1 < x && x < 3

多元运算符

·一元运算符:只需要一个数据就可以进行操作的运算符。例如:取反!、自增++、自减–
·二元运算符:需要两个数据才可以进行操作的运算符。例如:加法+、赋值=
·三元运算符:需要三个数据才可以进行操作的运算符。
三元运算符格式:
数据类型变量名称=条件判断?表达式A:表达式B;
三元运算符流程:
首先判断条件是否成立:
如果成立为true,那么将表达式A的值赋值给左侧的变量;
如果不成立为false,那么将表达式B的值赋值给左侧的变量;
二者选其一。
注意事项:
1.必须同时保证表达式A和表达式B都符合左侧数据类型的要求。
2.三元运算符的结果必须被使用。

public static void mian(){
    int a=7;
    int b=77;
    a > b ? a : b;//错误，结果没有输出或传递给任何变量。
    double c = 77.7;
    System.out.println(a > c ? a : c);//错误，a和c不是同一个数据类型。
}

方法入门

概念：

将一个功能抽取出来，把代码单独定义在一个大括号内，形成一个单独的功能。

定义格式：

修饰符 返回值类型 方法名 （参数列表）｛
     代码...        
    return ;     
｝
eg:
public static void 方法名称(){
    方法体;
}

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

注意：

1.方法定义的先后顺序无所谓。

2.方法的定义不能产生嵌套包含关系。

3.方法定义好了之后，不会执行的。如果要想执行，一定要进行方法的[调用]。

调用方法：

方法名称();

package DemoMethod;
/**
 * @author Edwin D
 * @date 2020.4.4 下午 1:37
 */
public class DemoMethod1 {
    public static void main(String[] args) {
        System.out.println("现");
        System.out.println("在");
        System.out.println("没");
        System.out.println("调");
        System.out.println("用");
        System.out.println("方");
        System.out.println("法");
        System.out.println("+++++++++++++++++++");
        method1();
    }
    public static void method1(){
        System.out.println("现");
        System.out.println("在");
        System.out.println("调");
        System.out.println("用");
        System.out.println("方");
        System.out.println("法");
    }
}

JShell脚本

拓展内容

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

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

4.在给变量进行赋值的时候，如果右侧的表达式当中全都是常量，没有任何变量，那么编译器javac将会直接将若干个常量表达式计算得到结果。
Eg: short result = 5 + 8; //等号右边全都是常量，没有任何变量参与运算。编译之后，得到的.class字节码文件当中相当于[直接就是] :
short result = 13;
右侧的常量结果数值，没有超过左侧范围，所以正确。这称为“编译器的常量优化”。
但是注意:一旦表达式当中有变量参与，那么就不能进行这种优化了。

public class Demo13Notice 1
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
}

参考文献：

《黑马Java基础班视频》

《黑马Java基础教材笔记》

2020.04.04