JAVA基础学习（二）

傷城~ 2021-12-22 20:43 325阅读 0赞

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);
        }
    }

运行结果：

![1481544-20190423091709958-1401051886.png][]

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

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

1 public class main{
    2     public static void main(String[] args){
    3         double d = 3.14;
    4         System.out.println(d);
    5         
    6         int i = (int)d;//强制类型转换
    7         System.out.println(i);
    8     }
    9 }

程序运行结果：

![1481544-20190423092556872-917234243.png][]

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

程序运行结果：

![1481544-20190423092914680-926382268.png][]

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

7、运算符

*       算术运算符：

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

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

注：++的置后性

1 public class main{
     2     public static void main(String[] args){
     3         
     4         //+从左往右结合
     5         System.out.println("加法");
     6         System.out.println("1+2="+1+2);
     7         System.out.println("1+2="+1+2+3);
     8         System.out.println("1+2="+(1+2));
     9         
    10         //除法 /
    11         System.out.println("除法");
    12         int i = 100;
    13         int j = 11;
    14         System.out.println(i/j);//整数运算只能得到整数
    15         double m = 3;
    16         double n = 2;
    17         double a = m/n;
    18         System.out.println(m/n);
    19         System.out.println(a);
    20         
    21         //自增
    22         //符号写前写后，在变量自己独立存在时，没有区别
    23         System.out.println("符号写前写后，在变量自己独立存在时，没有区别");
    24         i++;
    25         ++j;
    26         System.out.println(i);
    27         System.out.println(j);
    28         //符号写前写后，在参与其他运算时，有区别
    29         System.out.println("符号写前写后，在参与其他运算时，有区别");
    30         int k =6;
    31         int b = k++;//b=k=6后，k=k+1=7
    32         int c = ++k;//k=k+1=8,c=k=8
    33         System.out.println(b);
    34         System.out.println(c);
    35         System.out.println(k);
    36         
    37         System.out.println("++的置后性");
    38         int f = 1;
    39         int g ;
    40         g = f++ + 10;
    41         System.out.println(f);
    42         System.out.println(g);
    43                 
    44     }
    45 }

程序运行结果：

![1481544-20190423100109801-1485585848.png][]

*       赋值运算符：

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

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

1 public class main{
     2     public static void main(String[] args){
     3         byte b = 1;
     4         b = (byte)(b + 1);//强制转换
     5         System.out.println(b);
     6         
     7         byte b1 = 1;
     8         b1 +=1;//等同于(byte)(b1 + 1)，+=会自动强制转换
     9         System.out.println(b1);
    10                 
    11     }
    12 }

程序运行结果：

![1481544-20190423101710651-1240986075.png][]

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

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

*       逻辑运算符：

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

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

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

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

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

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

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

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

1 public class main{
     2     public static void main(String[] args){
     3         int i = 1;
     4         int j = 2;
     5         System.out.println(3>4 & ++i>1);
     6         System.out.println(i);
     7         int m = 1;
     8         int n = 2;
     9         System.out.println(3>4 && ++m>1);//++m>1被短路
    10         System.out.println(m);
    11                 
    12     }
    13 }

程序运行结果：

![1481544-20190423104118337-694463886.png][]

*       三元运算符

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

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

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

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

程序运行结果：

![1481544-20190423104814805-1695070535.png][]

day3

1、引用数据类型

*       引用数据类型的使用：

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

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

变量名.方法名();

*       Scanner类

使用步骤：

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

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

程序运行结果：

![1481544-20190423125930187-1582383873.png][]

*       Random类

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

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

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

程序运行结果：

![1481544-20190423131625275-2076402639.png][]

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语句与三元运算转化：

1 public class main{
     2     public static void main(String[] args){
     3         int i = 1;
     4         int j = 2;
     5         if(i>j){
     6             System.out.println(i);
     7         }else{
     8             System.out.println(j);
     9         }
    10         //将if…else转换为三元运算
    11         int k = i>j ? i:j;
    12         System.out.println(k);        
    13     }
    14 }

程序运行结果：

![1481544-20190423142528909-1034266531.png][]

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

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

3、循环语句

*       while循环

while(条件)\{

循环体

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

*       for循环

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

循环体

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

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

增量：变量自增情况

*  do…while

do\{

循环体

\}while(条件);

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

*  死循环

1、while(true)\{

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

*  嵌套循环

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

1 public class main{
     2     public static void main(String[] args){
     3         for(int i = 1;i<9;i++){
     4             for(int j = 1;j<=i;j++){
     5                 System.out.print("*");
     6             }
     7             System.out.println();
     8         }
     9     }
    10 }

程序执行结果：

![1481544-20190423153309902-318633379.png][]

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

1 public class main{
     2     public static void main(String[] args){
     3         for(int i = 1;i<9;i++){
     4             for(int j = 1;j<=i;j++){
     5                 if(i == 4){
     6                     System.out.println("这里是第三行");
     7                     break;
     8                 }
     9                 System.out.print("*");
    10                 
    11             }
    12             System.out.println();
    13         }
    14     }
    15 }

程序执行结果

![1481544-20190423153737567-1826453123.png][]

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

1 public class main{
     2     public static void main(String[] args){
     3         a:for(int i = 1;i<9;i++){
     4             for(int j = 1;j<=i;j++){
     5                 if(i == 4){
     6                     System.out.println("这里是第三行");
     7                     break a;
     8                 }
     9                 System.out.print("*");
    10                 
    11             }
    12             System.out.println();
    13         }
    14     }
    15 }

程序运行结果：

![1481544-20190423154109044-412401941.png][]

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

1 public class main{
     2     public static void main(String[] args){
     3         for(int i = 1;i<9;i++){
     4             for(int j = 1;j<=i;j++){
     5                 if(j == 4){
     6                     System.out.print("j=4");//将第四个*改为“j=4”
     7                     continue;
     8                 }
     9                 System.out.print("*");
    10                 
    11             }
    12             System.out.println();
    13         }
    14     }
    15 }

程序运行结果：

![1481544-20190423154700447-2008807089.png][]

简单应用：猜数字小游戏

1 import java.util.Random;
     2 import java.util.Scanner;
     3 public class main{
     4     public static void main(String[] args){
     5         Random r = new Random();
     6         int n = r.nextInt(101);
     7         System.out.println("****猜数字游戏****");
     8         System.out.println("请输入一个0-100的整数");
     9         while(true){
    10             Scanner sc = new Scanner(System.in);
    11             int m = sc.nextInt();
    12             if(m<n){
    13                 System.out.println("对不起，您猜小了");
    14             }else if(m>n){
    15                 System.out.println("对不起，您猜大了");
    16             }else{
    17                 System.out.println("恭喜您，猜对了！");
    18                 break;
    19             }
    20         }
    21     }
    22 }

程序运行结果：

![1481544-20190423155933811-1556350319.png][]

转载于:https://www.cnblogs.com/rr-sunrise/p/10755236.html

[1481544-20190423091709958-1401051886.png]: /images/20211220/2a2ffce9f1214d13a5b8df0d5d45a152.png
[1481544-20190423092556872-917234243.png]: /images/20211220/ca41a28571f4412f80e5b4b67012d22b.png
[1481544-20190423092914680-926382268.png]: /images/20211220/857f3f7fce754975bd542f16d6bb817d.png
[1481544-20190423100109801-1485585848.png]: /images/20211220/8b9375f9afa44c61854b6a0a11086421.png
[1481544-20190423101710651-1240986075.png]: /images/20211220/4079fd33c802435a8e7ef25961fb8a07.png
[1481544-20190423104118337-694463886.png]: /images/20211220/4526f28aff6b4f18b50d196b856fa4b3.png
[1481544-20190423104814805-1695070535.png]: /images/20211220/c09ad6f2f1aa4952bf8c7cbbb4dba5f8.png
[1481544-20190423125930187-1582383873.png]: /images/20211220/9b6e558190954cacad0340af42bd0a0d.png
[1481544-20190423131625275-2076402639.png]: /images/20211220/ebd8bd117b1d4490b5b0174c99e340b1.png
[1481544-20190423142528909-1034266531.png]: /images/20211220/8e20fb9839e140fa98f969d6644b2f4e.png
[1481544-20190423153309902-318633379.png]: /images/20211220/3aadb0a8a2a24e58bdcb2a5c72620124.png
[1481544-20190423153737567-1826453123.png]: /images/20211220/d3653dd8fdaa4d05b4138fc6d04051cc.png
[1481544-20190423154109044-412401941.png]: /images/20211220/d5b2962e11a14de7923d5b039c45297c.png
[1481544-20190423154700447-2008807089.png]: /images/20211220/d93a76c0aa734940a87bde18e3682a36.png
[1481544-20190423155933811-1556350319.png]: /images/20211220/8aeb2e04da84467a82a2f1ce542a3e42.png