JAVA基础学习（二）

day2

1、变量

      变量：内存中装载数据的小盒子，你只能用它来存数据和取数据。

2、计算机存储单元

     计算机存储设备的最小信息单元叫“位（bit）”,又称之为“比特位”，通常用小写字母b表示。

     计算机最小的存储单元叫“字节（byte）”，通常用大写字母B表示，字节是由连续的8个位组成。

     常用存储单位间的转换：

           1B(字节) = 8bit

           1KB = 1024B

           1MB = 1024KB

           1GB = 1024MB

           1TB = 1024GB

           1PB = 1024TB

3、常量与类型

     注：java中默认的整数类型是int类型，long型需在数据后加L,如，100L，12345678901L

            java中默认的浮点类型是double类型，float型须在数据后加F，如，4.1F

4、定义变量（创建变量）

     定义变量的语法格式：数据类型 变量名 = 数据名;（定义变量的三要素）

     注：同一个变量重复赋值，以最后一次赋值为准

            String是引用类型，不属于基本类型，String类中有final关键字，不可被继承。

5、变量使用的注意事项

•      变量定义时可以不赋值，可使用时再赋值，但不赋值不可使用。（赋值=初始化变量）
•      变量有一定的作用范围：定义的一对大括号之内
•      变量不可重复定义

6、数据类型转换

     数据类型转换原则：范围小的数据类型值可以直接转换为范围大的数据类型值

                                     范围大的数据类型值不可以直接转换为范围小的数据类型值

     数据类型范围从小到大：byte -> short -> int -> long -> float -> double

•      自动类型转换：表示小范围的数据类型转换成范围大的数据类型，这种方式称为自动类型转换

     注：boolean类型不参与类型转换

     自动类型转换格式：范围大的数据类型 变量 = 范围小的数据类型值，如，double d = 1000;

public class main{
    public static void main(String[] args){
        double d = 1000;//自动类型转换
        System.out.println(d);
        
        int i = 100;
        double d1 = i;//自动类型转换
        System.out.println(d1);
        
        byte b = 10;
        int i1 = b;//自动类型转换
        System.out.println(i1);
    }
}

运行结果：

•      数据类型的强制转换：数据类型取值范围大的，转换成取值范围小的

       数据类型的强制转换格式：被转后的数据类型 变量名 = （被转换后的数据类型）要被转的数据

public class main{
    public static void main(String[] args){
        double d = 3.14;
        System.out.println(d);
        
        int i = (int)d;//强制类型转换
        System.out.println(i);
    }
}

程序运行结果：

public class main{
    public static void main(String[] args){
        byte b =(byte)200;//强制转换，损失精度，丢数据
        System.out.println(b);
    }
}

程序运行结果：

     注：强制类型转换没有特殊要求最好不要做，会损失精度，丢数据。

7、运算符

•      算术运算符：

           +（正号、加、连接字符串）、-（负号、减）、*（乘）、/（除）、%（取模）、++（自增1）、--（自减1）

     注：“+”遇到字符串变成连接符号，任何类型只要和字符串+，所有的数据都变成了字符串

     注：++的置后性

public class main{
    public static void main(String[] args){
        
        //+从左往右结合
        System.out.println("加法");
        System.out.println("1+2="+1+2);
        System.out.println("1+2="+1+2+3);
        System.out.println("1+2="+(1+2));
        
        //除法 /
        System.out.println("除法");
        int i = 100;
        int j = 11;
        System.out.println(i/j);//整数运算只能得到整数
        double m = 3;
        double n = 2;
        double a = m/n;
        System.out.println(m/n);
        System.out.println(a);
        
        //自增
        //符号写前写后，在变量自己独立存在时，没有区别
        System.out.println("符号写前写后，在变量自己独立存在时，没有区别");
        i++;
        ++j;
        System.out.println(i);
        System.out.println(j);
        //符号写前写后，在参与其他运算时，有区别
        System.out.println("符号写前写后，在参与其他运算时，有区别");
        int k =6;
        int b = k++;//b=k=6后，k=k+1=7
        int c = ++k;//k=k+1=8,c=k=8
        System.out.println(b);
        System.out.println(c);
        System.out.println(k);
        
        System.out.println("++的置后性");
        int f = 1;
        int g ;
        g = f++ + 10;
        System.out.println(f);
        System.out.println(g);
                
    }
}

程序运行结果：

•      赋值运算符：

           =（赋值）、+=（加后赋值）、-=（减后赋值）、*=（乘后赋值）、/=（除后赋值）、%=（取模后赋值）

     注：+=的自动强制转换，其余类似

public class main{
    public static void main(String[] args){
        byte b = 1;
        b = (byte)(b + 1);//强制转换
        System.out.println(b);
        
        byte b1 = 1;
        b1 +=1;//等同于(byte)(b1 + 1)，+=会自动强制转换
        System.out.println(b1);
                
    }
}

程序运行结果：

•      比较运算符（关系运算符）：

          ==（等于）、！=（不等于）、<（小于）、>（大于）、<=（小于等于）、>=（大于等于）结果都是布尔类型，true或false

•      逻辑运算符：

           &（与）、|（或）、！（非）、^（异或）、&&（短路与）、||（短路或）  对两个boolean类型数据之间进行计算，结果也是布尔类型

     &：一边是false，运算结果就是false

     |：一边是true，运算结果就是true

     ！：取反：！false结果为true，!true结果为false

     ^：两边相同为false，相同为true

     &&：一边是false，一边不运行

     ||：一边是true,一边不运行

     注：&&和||的意义是提高运行效率

public class main{
    public static void main(String[] args){
        int i = 1;
        int j = 2;
        System.out.println(3>4 & ++i>1);
        System.out.println(i);
        int m = 1;
        int n = 2;
        System.out.println(3>4 && ++m>1);//++m>1被短路
        System.out.println(m);
                
    }
}

程序运行结果：

•      三元运算符

           公式：布尔表达式 ？ 结果1：结果2；

                      布尔表达式结果是true，三元运算符的结果是，结果1

                      布尔表达式结果是false，三元运算符的结果是，结果2

public class main{
    public static void main(String[] args){
        
        System.out.println(1>2?11:21);
        String s = 1<=2?"是":"否";
        System.out.println(s);
    }
}

程序运行结果：

 

 

day3

1、引用数据类型

•      引用数据类型的使用：

           数据类型 变量名 = new 数据类型();

     每种引用类型都有其功能，我们可以通过“.”调用该类型实例的功能

           变量名.方法名();

•      Scanner类

       使用步骤：

1. 导入包；import java.util.Scanner
2. 公式，创建出Scanner类型变量
3. 变量，使用Scanner类中的功能，完成键盘输入

import java.util.Scanner;
public class main{
    public static void main(String[] args){
        //创建出Scanner类型变量
        Scanner sc = new Scanner(System.in);
        //接收键盘输入
        int i = sc.nextInt();//只能接收整数
        System.out.println(i);
        String s = sc.next();//接收字符串
        System.out.println(s);
        
    }
}

程序运行结果：

•      Random类

1. 导入包；import java.util.Random
2. 公式，创建出Random类型变量
3. 变量，使用Randomr类中的功能，产生随机数

     注：随机数又叫伪随机数，是虚拟机根据人写好的一个算法生成出来的，是可以被某些人算出的

import java.util.Random;
public class main{
    public static void main(String[] args){
        //创建出Randomr类型变量
        Random r = new Random();
        //调用Random的功能，产生一个随机数，结果是整数型（int）
        //可以规定随机数的范围  0 - 指定的整数，如，nextInt(100),随机数范围是0 - 99
        int i = r.nextInt(100);
        System.out.println(i);
        //产生1-100的随机数
        int j = r.nextInt(100)+1;
        System.out.println(j);
        
        //产生浮点的随机数，无范围指定，范围固定为0.0 - 1.0（可能为0.0,不可能为1.0）
        double d = r.nextDouble();
        System.out.println(d);
        
        
        
    }
}

程序运行结果：

2、选择结构

•      if语句：

     if(条件){

           if语句的执行体

     }

     注：如果条件成立，执行if语句的执行体

            如果条件不成立，什么也不做，程序继续向下执行

•      if…else语句：

     if（判断条件）{

           if的执行体

     }else{

           else的执行体

       }

     当if中的条件为true时，执行if的执行体

                            false时，执行else的执行体

•      if…else if……else语句：

     if(判断条件1){

           if的执行体1

     }else if(判断条件2){

           if的执行体2

     }else{

     }

     注：else if 可以有很多个，适用于多条件语句

            如果有一个i判断条件成立，则执行其后的if执行体，且其后的所有判断条件及其执行体不再执行。

 

•      选择结构if语句与三元运算转化：

public class main{
    public static void main(String[] args){
        int i = 1;
        int j = 2;
        if(i>j){
            System.out.println(i);
        }else{
            System.out.println(j);
        }
        //将if…else转换为三元运算
        int k = i>j ? i:j;
        System.out.println(k);        
    }
}

程序运行结果：

     注：三元运算必须有结果，if…else结构可以都不执行

            三元运算的格式要简单的多，if…else可以有更多条件判断

3、循环语句

•      while循环

       while(条件){

           循环体

     }

     当条件为真时，执行循环体，执行完循环体后再次判断while中的条件，如果条件仍然为真，继续执行循环体，直到条件为假时，退出循环。

•      for循环 

       for(初始化变量;条件;增量){

            循环体

       }

       初始化变量：定义变量，用来控制循环的次数

       条件：当条件为真时，执行循环体，条件为假时，结束循环

       增量：变量自增情况

• do…while

       do{

             循环体

       }while(条件);

       注：无论条件是否成立，都会先执行一次循环体

• 死循环

        1、while(true){

          }

         2、for(;;){ }或for(;true;){ }

• 嵌套循环

       注：总的循环次数=内循环次数*外循环次数

public class main{
    public static void main(String[] args){
        for(int i = 1;i<9;i++){
            for(int j = 1;j<=i;j++){
                System.out.print("*");
            }
            System.out.println();
        }
    }
}

程序执行结果：

• break关键字：终止当前循环

public class main{
    public static void main(String[] args){
        for(int i = 1;i<9;i++){
            for(int j = 1;j<=i;j++){
                if(i == 4){
                    System.out.println("这里是第三行");
                    break;
                }
                System.out.print("*");
                
            }
            System.out.println();
        }
    }
}

程序执行结果

  

    注：break的特殊用法（可用于结束外循环）：

public class main{
    public static void main(String[] args){
        a:for(int i = 1;i<9;i++){
            for(int j = 1;j<=i;j++){
                if(i == 4){
                    System.out.println("这里是第三行");
                    break a;
                }
                System.out.print("*");
                
            }
            System.out.println();
        }
    }
}

程序运行结果：

• continue关键字：终止本次循环，开始下一次循环

public class main{
    public static void main(String[] args){
        for(int i = 1;i<9;i++){
            for(int j = 1;j<=i;j++){
                if(j == 4){
                    System.out.print("j=4");//将第四个*改为“j=4”
                    continue;
                }
                System.out.print("*");
                
            }
            System.out.println();
        }
    }
}

程序运行结果：

 

简单应用：猜数字小游戏

import java.util.Random;
import java.util.Scanner;
public class main{
    public static void main(String[] args){
        Random r = new Random();
        int n = r.nextInt(101);
        System.out.println("****猜数字游戏****");
        System.out.println("请输入一个0-100的整数");
        while(true){
            Scanner sc = new Scanner(System.in);
            int m = sc.nextInt();
            if(m<n){
                System.out.println("对不起，您猜小了");
            }else if(m>n){
                System.out.println("对不起，您猜大了");
            }else{
                System.out.println("恭喜您，猜对了！");
                break;
            }
        }
    }
}

程序运行结果：