Java学习第四天（数据类型、运算符、类型转换、流程控制）6-27

Love The Way You Lie 2021-12-21 01:23 214阅读 0赞

# 【1】Java是一种强类型的语言： #

是因为常量需要有数据类型的，并且变量也必须声明它的数据类型。

# 【2】变量的类型 #

数据类型分为两部分：基本数据类型、引用数据类型

基本数据类型分为：数值型，字符型，布尔型，数值型又细分为2种：整数和浮点数

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQxNTgxMTU0_size_16_color_FFFFFF_t_70][]

一共是四大类八小种，除了基本数据类型剩下的就都是引用数据类型。

# 整数类型：分为二进制、八进制、十进制、十六进制。 #

其他进制往十进制转换是 用乘法来计算。

## 十进制往其他类型是用除法来计算。 ##

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQxNTgxMTU0_size_16_color_FFFFFF_t_70 1][]

## 十进制往十六进制进行转换： ##

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQxNTgxMTU0_size_16_color_FFFFFF_t_70 2][]

一般的整形默认为是int型，浮点型默认为double型

如果需要对float型，则需要在小数点后面加一个F，比如说3.14F

浮点数有很大的误差，所以一半比较的话尽量不用两种类型进行比较，需要用decimal类型来进行比较。

public class TestVar04{
            public static void main(String[] args){
                    //浮点类型：
                    //默认的浮点型都是double类型：
                    double d1=3.14;//十进制
                    System.out.println(d1);
                    double d2=3145E-3;//科学计数法
                    System.out.println(d2);
                    
                    double d3=25.456724319578794636;
                    System.out.println(d3);
                    
                    float f1=2345.4F;默认的浮点型都是double类型,要是先把一个小数给float类型，后面必须加上 F或者f
                    System.out.println(f1);
                    float f2=25.456724319578794636F;
                    System.out.println(f2);
                    
                    //不要进行浮点数的比较：
                    float f4=0.3F;//0.2999999
                    double d4=0.3;//0.30000000001
                    //比较f4和d4是否相等：
                    System.out.println(f4==d4);
                    /*
                    =赋值：将等号右侧的值赋给等号左侧
                    ==：进行判断：判断==左右两侧的值是否相等，要么相等（true）要么不相等(false)。
                    
                    */
            
            }
            
            
    }

单引号用来表示字符 'a'  ,"a"是用来表示字符串。

public class TestVar07{
            public static void main(String [] args){
                    //定义一个字符型的变量：
                    //字符型：单引号引起来的单个字符--》在java中无论是字母，数字，汉字--》都是占用一个字符（2个字节）。
                    char ch1='a';
                    System.out.println(ch1);
                    char ch2='1';
                    System.out.println(ch2);
                    char ch3='你';
                    System.out.println(ch3);
                    char ch4=' ';
                    System.out.println(ch4);
                    
                    System.out.println("-------------转义字符--------------------");
                    //转义字符  \将后面的字母转换为特殊含义
                    char ch5='\n';// \n-->换行
                    System.out.println("aaa"+ch5+"bbb");
                    System.out.println("aaa\nbbb");
                    
                    System.out.println("aaa\tbbb");// \t-->制表符
                    
                    System.out.println("aaa\bbbb");//aabbb  \b      光标向左退一次
                    
                    System.out.println("aaa\rbbb");//bbb   \r 回到本行光标最起始位置上。
                    
                    System.out.println("你好\"java\"");
                    System.out.println("你好“java”");
                    
                    System.out.println("-------------字符：--------------------");
                    char ch6='a';
                    System.out.println(ch6);
                    System.out.println(ch6+19);//116
                    System.out.println(116-ch6);
                    //表面上字符就是字面常量的样子，但是实际在参与到运算中的时候，底层其实是一个数字在参与运算。
                    //这个数：'a'-->97  --->ASCII码
                    
                    char ch7='中';
                    System.out.println(ch7);
                    System.out.println(ch7+70);
                    //表面上字符就是字面常量的样子，但是实际在参与到运算中的时候，底层其实是一个数字在参与运算。
                    //这个数：'中'---》20013  --->Unicode码（ASCII码是Unicode码的前128位）
                    
                    System.out.println("-------------扩展：--------------------");
                    char ch8=(char)20013;
                    System.out.println(ch8);
                    
                    int i=(int)'中';
                    System.out.println(i);
                    
                    char ch9=20013;
                    System.out.println(ch9);
                    
                    int i2='中';
                    System.out.println(i2);
                    
                    
            }
            
    }

# 类型转换方面：一半类型小的往类型大的转换是自动转换，如果类型大的往类型小的转换时需要强制转换。 #

在类型转换的时候，会自动的向表达式等级高的类型进行转换。

public class TestVar08{
            public static void main(String [] args){
                    double d=12;
                    System.out.println(d);
                    int a=(int)9.3;
                    System.out.println(a);
                    /*
                    【5】不同数据类型转换：
                    小--》大：自动转换
                    大--》小：强制转换（强转）	
                    */
                    
                    /*
                    【1】四类八种不同类型都可以参与到运算中去（除了布尔类型）
                    【2】不同的类型有一个等级之分：
                    byte,short,char-->int--->long--->float--->double 
                    按照这个等级（从低到高的等级，）
                    在运算的时候，表达式中的类型会优先向高等级转换。
                    
                    double d2=12+9.4F+18.5+100L+'a';
                             =12.0+9.4+18.5+100.0+97.0
                                     =。。。
                    
                    【3】表达式中
                    左侧类型=右侧类型：直接赋值即可
                    左侧类型>右侧类型：直接赋值即可
                    左侧类型<右侧类型：必须整体进行强转
                    */
                    //double d2=12+9.4F+18.5+100L+'a'+true;
                    int d2=(int)(12+9.4F+18.5+100L+'a');
                    System.out.println(d2);
                    
                    //【4】特殊情况：byte,short,char 只要在表述范围中可以直接赋值，不用强转。
                    byte b=12;
                    System.out.println(b);
            }
    }

# 关于扫描器方面： 首先需要导入包 #

import java.util.Scanner;

# 然后创建Scanner对象，并且去找一个变量接受它 #

Scanner sc=new Scanner(System.in);
    int A=sc.nextInt();//接收的是整数
    String B=sc.next();//接收的是String类型的字符串
    double C=sc.nextDouble();//接收的是double类型

类型转换的习题：

char i =50; //定义变量i 为50，注意这里没有单引号，所以此时是int类型，需要找到Ascii表中50对应的位置
    System.out.println(i);//输出类型为char 的i的值
    System.out.println(i+30);//此时进行相加运算，表达式中最高级为int类型，所以直接50+30

# 逻辑运算符： #

&  &&  |    ||    ！  ^

首先&是逻辑与，也就是从表达式左边往表达式右边进行判断，逻辑与必须表达式两边都为true，才能是true  否则为false

&&短路与，短路与的判断方法与逻辑与是相同的，但是短路与只要表达式开始有false，便直接得出为false，再不进行判断

|逻辑或，也是表达式的左边往右边进行判断，逻辑或是一true，整个表达式便为true，但是两边都需要判断完才可以。

||短路或 也是与逻辑或的判断方式一样，但是只要遇见true，便直接判断整个表达式为true，不接着往下进行判断

! 直接取反

^  异或，异或的意思是 只要相同就是false，不同为true。

public class TestOpe01{
            public static void main(String [] args){
                    //&  逻辑与  只要有一个是false，结果一定是false
                    System.out.println(true&true);
                    System.out.println(true&false);
                    System.out.println(false&true);
                    System.out.println(false&false);
                    
                    //&& 短路与  只要第一个表达式返回结果是false，那么第二个表达式就不会再运算了，结果直接为false
                    System.out.println(true&&true);
                    System.out.println(true&&false);
                    System.out.println(false&&true);
                    System.out.println(false&&false);
                    
                    
                    System.out.println("-----------------------------------");
                    // |  逻辑或  只要有一个为true，结果就是true
                    System.out.println((5<9)|true);
                    System.out.println(true|(9==3));
                    System.out.println(false|true);
                    System.out.println(false|false);
                    
                    //||  短路或  只要第一个表达式为true，那么第二个表达式不用计算了，直接结果就是true
                    System.out.println(true||true);
                    System.out.println(true||false);
                    System.out.println(false||true);
                    System.out.println(false||false);
                    System.out.println("-----------------------------------");
                    //  !  非
                    System.out.println(!true);
                    System.out.println(!false);
                    System.out.println("-----------------------------------");
                    // ^  异或：相同为false，不同为true
                    System.out.println(true^true);
                    System.out.println(true^false);
                    System.out.println(false^true);
                    System.out.println(false^false);
                    
            }
    }

# **三目运算符     A？B:C;** #

逻辑是判断A是否为true，如果是true，则执行表达式B，如果为false，则执行表达式C。

if语句：

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQxNTgxMTU0_size_16_color_FFFFFF_t_70]: /images/20211221/ba0a05f9d23a43a6b7d4e1f7e13a6ab2.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQxNTgxMTU0_size_16_color_FFFFFF_t_70 1]: /images/20211221/8b46d23842664372a2c655c097e1d634.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQxNTgxMTU0_size_16_color_FFFFFF_t_70 2]: /images/20211221/39a4c50aebc34427944798dbde31576c.png