二.变量、数据类型、运算符、Scanner使用

已于 2024-08-14 18:16:25 修改
阅读量399 收藏 13
点赞数 12
分类专栏： 2024从头学习JAVA 文章标签： java idea 开发语言
于 2024-08-14 17:17:08 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_46360048/article/details/141195289
版权

一、变量

1.1 概念

在程序运行中，可以发生改变的量。

在内存中，需要一个空间，临时存储数据。

1.2 变量的组成及定义

  • 数据类型 变量名 值

  • 声明的同时并赋值

    • 数据类型 变量名 = 值;

  • 先声明，后赋值

    • 数据类型 变量名; 变量名 = 值

  • 多个同类型的变量声明与赋值。

    • 数据类型 变量名1,变量名2,变量名3;
    • 变量名1 = 值；变量名2 = 值；变量名3 = 值；

  • 代码实现：

    • public class VarTest{
	public static void main(String[] args){
		//1.声明同时 赋值
		int a = 10;
		
		System.out.println(a);
		
		//2.先声明，后赋值
		int b;
		b = 20;
		System.out.println(b);
		
		//3.同类型的声明与赋值（了解）
		int c = 30,d,e;
		//c = 30;
		//d = 40;
		e = 50;
		System.out.println(c);
		System.out.println(d);
		System.out.println(e);
	}
}

    1.3 变量的使用注意事项

    public class VarTest1{
	public static void main(String[] args){
		//1.变量不初始化，不能使用
		int a = 20;
		
		System.out.println(a);
		//2.在相同作用域（{}作用域）中，不能定义重名的变量
		//int a = 30;
		//System.out.println(a);
		
		//3.变量在使用时，可以与""字符串拼接
		int b = 20;
		int c = 30;
		int d = 40;
		//+在Java中，任何变量与字符串相加，实为拼接。
		System.out.println("b="+b+",c="+c+",d="+d);
		//b=20,c=30,d=40
		
		//4.变量在作用域中，可以更改值
		d = 128;
		System.out.println("d="+d);
	}
}

二、数据类型

2.1 概念

  • 不同的数据，分配不同的空间，来存储数据。避免空间的不足、空间的浪费。
  • 基本数据类型：
    • 4类8种
    • 整数型：byte 1字节、short 2字节、int 4字节、long 8字节
    • 浮点数型：float 4字节、double 8字节
    • 字符型：char 2字节
    • 布尔型：boolean 1字节
  • 引用数据类型：
    • 基本数据类型以外的全是引用数据类型

2.2 计算机存储单位

  • 字节->kb->mb->gb->tb->pb
  • 以上单位都是1024进制。
  • bit（位）->字节 8个bit ->1字节
  • 0111 1111

2.3 整数类型

/*
	byte   1  -2^7 ~ 2^7-1   -128 ~ 127
	short  2  -2^15 ~ 2^15-1
	int    4  -2147483648~2147483647
	long   8  -922京 ~ 922京
	
	1、int是Java中整数的默认类型。 超过int类型，则提示过大的整数
	2、超过int范围的数字，要存储在long里，要加l/L的标识
*/
public class IntTest{
	public static void main(String[] args){
		byte b = 127;
		System.out.println("b="+b);
		
		short s = 32767;
		System.out.println("s="+s);
		
		int i = 21_4748_3647;
		System.out.println("i="+i);
		
		long l = 2147483648L;
		System.out.println("l="+l);
	}
	
}

2.4 浮点数类型

/*
	float:  4   单精度
	double: 8   双精度
	   符号位  指数位  尾数位
float 	 1       8      23    838_8608  = 7位精确小数
double   1       11     52     4503_5996_2737_0496   16位精确小数  最高

	
	1、浮点数的默认类型是double
	2、存储float类型的数据，要加f/F的标识
	3、能精确模拟的小数，就不会保留多余的位数
	4、要用小数做运算的场景，不会用float和double，BigDecimal
	5、浮点数类型的范围>整数类型。
*/
public class DoubleTest{
	public static void main(String[] args){
		float f = 3.14F;
		System.out.println("f="+f);
		
		double d = 3.14;
		System.out.println("d="+d);
		
		double dd = 3.111111111111111111111111111;
		System.out.println(dd);
		
		double d1 = 0.1;
		double d2 = 0.2;
		System.out.println(d1+d2);//0.30000000000000004
		
		double d3 = 0.3;
		System.out.println(d3);
		
		double score = 99.5;
	
	}
	
}

2.5 字符类型

/*
	char 表示单个字符  0101  ASCII   本质存储的是字符的编码值
	
	1、Java中char存储的unicode编码 所有的国家的文字都可以表示
	2、char可以存储字符，字符会转换为编码值，也可以直接存储编码值
	3、char不能直接存储空字符''  '\0'可以  空格也可以。
*/
public class CharTest{
	public static void main(String[] args){
		//0 1   男  女
		//char c7 = ' ';
		char c7 = '\0';
		System.out.println("c7="+c7);
		
		char c = 'A';
		System.out.println("c="+c);
		
		char c2 = 'の';
		System.out.println("c2="+c2);
		
		char c3 = '你';
		System.out.println("c3="+c3);
		
		char c4 = 65;
		System.out.println("c4="+c4);
		
		char c5 = 20320;
		System.out.println("c5="+c5);
		
		//了解
		char c6 = '\u4f60';
		System.out.println("c6="+c6);
	}
	
}

转义字符：

/*
	转义字符：
		\：将普通字符转换为特殊的符号
			将特殊符号转换为普通字符
	\n：换行
	\t：一个水平制表位  大空格
	\"：将字符串的"转换为普通符号
	\': 字符的符号转换为普通符号
	\b：退格
	\r：回车  回到开头
*/
public class CharTest2{
	public static void main(String[] args){
		System.out.println("白日依山尽，\n黄河入海流。");
		
		System.out.println("白日依山尽，\t黄河入海流。");
		
		System.out.println("\"白日依山尽，\"\t黄河入海流。");
		
		System.out.println("白日依山尽，'黄河入海流。");
		
		System.out.println("白日依山尽，\b黄河入海流。");
		
		System.out.println("白日依山尽，\r黄河入海流。");
		
		char c = '\'';
		System.out.println(c);
	}
	
}

2.6 boolean类型 布尔

/*
	boolean 类型 取值  true  false
*/
public class BooleanTest{
	public static void main(String[] args){
		boolean b = true;
		b = false;
		System.out.println("b="+b);
		
		//做为判断的结果
		System.out.println(3 > 2);
	}
	
}

2.7 String 引用数据类型

  • String代表的是字符串，不属于基本数据类型，属于引用数据类型，类型是String，本质上是一个类，但是String类型定义赋值的时候，而是和基本数据类型一样。

  • public class StringTest{
	public static void main(String[] args){
		String s = "我是一个好人！";
		System.out.println(s);
		System.out.println("s="+s);
		System.out.println("请输入菜单的选项：");
		System.out.println("1：注册");
		System.out.println("2：登录");
	}
	
}

三、进制（了解）

3.1 进制的转换

十进制二进制八进制十六进制
0000
1111
21022
31133
410044
510155
611066
711177
81000108
91001119
10101012a或A
11101113b或B
12110014c或C
13110115d或D
14111016e或E
15111117f或F
16100002010

在这里插入图片描述

3.2 二进制存储

/*	
	无论是什么进制，最终计算机存储的都是二进制
	二进制是如何表示整数的：
		1.二进制存储的是补码  最高位 是符号位 0正数  1 负数
		2.正整数 三码合一 原码、 反码、补码是一样的。
		3.负整数
			原码：10进制转换为2进制 且最高位是1
			反码：最高位不变 其余位取反 
			补码：反码+1
		
		-6
			原码：1000 0110
			反码：1111 1001
			补码：1111 1010   计算机存储的
		-25 
			原码：1001 1001
			反码：1110 0110
			补码：1110 0111  计算机存储的
		
		
	byte = 1字节 = 8位
	1000 0000 
	0000 0000 0000 0000 
*/

public class DataTest{
	public static void main(String[] args){
		System.out.println(100);
		
		System.out.println("二进制：");
		System.out.println(0b110);
		System.out.println(0B110);
		
		System.out.println("八进制");
		System.out.println(0110);
		
		System.out.println("十六进制");
		System.out.println(0x11);
	}
}

四、数据类型转换

4.1 数据类型转换概念

  • 数据类型转换发生在7个基本数据类型里，除了boolean。
  • 等号左右两侧的类型不一致时，就会发生数据类型转换。

4.2 自动类型提升

/*
	byte    1   水杯
	short   2   水壶
	char    2   水壶
	int     4   水桶
	float   4   水缸
	long    8   水池
	double  8   大河
	
	自动类型提升：
		1.小的数据类型的值赋值给大的数据类型
		2.如果多个类型的值做运算，结果是最大的类型
		3.特殊：任何数据类型和String做+拼接时，结果都是String类型。
*/
public class ConvertTest{
	public static void main(String[] args){
		
		//System.out.println(9+7+"HelloWorld");
		System.out.println(9+"HelloWorld"+7);
		
		
		//2.如果多个类型的值做运算，结果是最大的类型
		float result = 30+20L+3.14F;
		System.out.println(result);
		
		//1.将小的数据类型的值赋值给大的数据类型
		byte b = 10;
		int i = b;
		System.out.println(i);
		
		char c = 'c';//99
		int i2 = c;
		System.out.println(i2);
		
		int i3 = 200;
		float f = i3;
		System.out.println(f);
		
		long l = 300;
		float f2 = l;
		System.out.println(f2);
	}
}

4.3 强制类型转换

/*
	byte    1   水杯
	short   2   水壶  -32768 ~ 32767
	char    2   水壶  无符号 0~65535
	int     4   水桶
	float   4   水缸
	long    8   水池
	double  8   大河
	
	自动类型提升：
		1.小的数据类型的值赋值给大的数据类型
		2.如果多个类型的值做运算，结果是最大的类型
		3.特殊：任何数据类型和String做+拼接时，结果都是String类型。
	强制类型转换：
		1.将大的数据类型的值赋值给小的数据类型
			小数据类型 变量名 = (小数据类型)大的数据类型值;
		2.小数转换为整数时，没有四舍五入，将小数位全部舍掉
*/
public class ConvertTest2{
	public static void main(String[] args){
								//128  64  8 
		int i5 = 200;//0000 0000 1100 1000
							//-128 64 8 = 
		byte b2 = (byte)i5;//1100 1000
		System.out.println(b2);
		
		//较大的整数转换为较小的整数，会发生数据截断和符号位发生改变
		int i4 = 128;
		byte b = (byte)i4;
		System.out.println(b);
		
		//整数转换为字符，在编码范围内的，不会丢失
		int i3 = 65555;
		char c = (char)i3;//超过取值范围，会发生数据截断。
		System.out.println(c);
		
		
		
		
		//1.小数转整数，小数位丢失
		double d = 3.99;
		int i = (int)d;
		System.out.println(i);
		
		float f = 9.6F;
		int i2 = (int)f;
		System.out.println(i2);
		
		
	}
	
}

4.4 表达式运算结果类型提升

/*
	
	常量值运算不会发生数据类型提升。
	byte、short、char类型的变量参与运算，结果都会提升为int
*/
public class ConvertTest3{
	public static void main(String[] args){
		//后边表达式是值与值的运算，
		byte b = 10 + 10;
		System.out.println(b);
		/*
		byte b2 = 10;
		byte b3 = b2 + 10;
		System.out.println(b3);
		*/
		char c = 'A'+1;
		System.out.println(c);
		
		char c2 = (char)(c+1);
		System.out.println(c2);
		
		
		
		//String str1 = 4;                       //判断对错： 错
		String str2 = 3.5f + "";               //判断str2对错：对 任意类型与字符串+都为拼接
		System.out.println(str2);
		System.out .println(3+4+"Hello!");     //输出：7Hello
		System.out.println("Hello!"+3+4);      //输出：Hello!34
		System.out.println('a'+1+"Hello!");    //输出：   98Hello!
		System.out.println("Hello"+'a'+1);     //输出：Helloa1
	
	}
}

五、运算符

5.1 算数运算符

算术运算符（7个） +、-、*、/、%、++、–

/*
 * 算数运算符：
 *   +
 *       加法运算
 *       字符串拼接
 *       正号
 *   -
 *       减法运算
 *       负号
 *   *
 *       乘法
 *   /
 *       除法
 *   %
 *       模运算
 *        取余数
 * */
public class OperatorTest1 {
    public static void main(String[] args) {
        System.out.println("********* % *********");
        System.out.println(5 % 2);//1
        System.out.println(5 % -2);//1  以被除数为准
        System.out.println(-5 % -2);

        System.out.println("********* + *********");
        int a = 10;
        int b = 20;
        System.out.println(a + b);
        int c = +30;
        System.out.println("c = " + c);
        System.out.println(9 + 6 + "HelloWorld");//拼接

        System.out.println("********* - *********");
        System.out.println(5 - 2);
        System.out.println(-20);
        System.out.println(5 - 2.5);

        System.out.println("********* * *********");
        System.out.println(2 * 3);
        System.out.println(2.5 * 2);

        System.out.println("********* / *********");
//        表达式中，整数与整数运算，除不尽时，只保留整数。小数位直接舍掉
        System.out.println(5 / 2);
//        System.out.println(5 / 0);//会报错：除数不能为0
        System.out.println(5.0 / 2);
    }
}


/*
*  ++
*   前++
*       ++a ： 先+1，再运算
*   后++
*       a++ ： 先运算，再加1
*  --
*
* */
class OperatorTest3{
    public static void main(String[] args) {
        int a= 5;
//        System.out.println(--a);
//        int result = --a + a + a--;
//        System.out.println("result = " + result);
    }
}
public class OperatorTest2 {
    public static void main(String[] args) {
        int a = 5;
//        System.out.println(++a); 6
//        System.out.println(a++);
//        System.out.println(a);
        //           5     6
//        int result = a++ + a;
        //            6    6
//        int result = ++a + a;
//        System.out.println("result = " + result);

        ++a;
        System.out.println(a);
    }
}

5.2 赋值运算符

赋值运算符符号解释
=等号右边的值，赋值给等号左边的变量
+=将符号左边的值和右边的值进行相加操作，最后将结果赋值给左边的变量
-=将符号左边的值和右边的值进行相减操作，最后将结果赋值给左边的变量
*=将符号左边的值和右边的值进行相乘操作，最后将结果赋值给左边的变量
/=将符号左边的值和右边的值进行相除操作，最后将结果赋值给左边的变量
%=将符号左边的值和右边的值进行取余操作，最后将结果赋值给左边的变量
/*
* 赋值运算符
*    =
*   +=
*   -=
*   *=
*   /=
*   %=
* 注意：不会更改原有的数据类型，在编译后，如果接受的变量的是小类型 会自动强转
* */
public class FuZhiTest {
    public static void main(String[] args) {
        int a = 10;
//        a = a + 10;
        a +=10;
        System.out.println("a = " + a);
        a-=5;//a = a-5;
        System.out.println("a = " + a);
        a*=10;// a= a* 10;
        System.out.println("a = " + a);
        a/=10;// a = a/10;
        System.out.println("a = " + a);
        a%=2;
        System.out.println("a = " + a);
        System.out.println("===========万恶的分割线=========");
        byte b = 20;
//        b = (byte)(b + 10);
        b +=10;
        System.out.println("b = " + b);

        char c = 'A';
//        c = c + 32;
        c +=32;
        System.out.println("c = " + c);

    }
}

5.3 关系/比较运算符

/*
* 关系/比较运算符
*  ==
*  !=
*  >
*  <
*  <=
*  >=
*  注意：关系运算符，比较的结果都是boolean类型
* */
public class CompareTest {
    public static void main(String[] args) {
        int a = 20;
        int b = 10;
        System.out.println(a == b);//false
        System.out.println(a != b);//true
        System.out.println(a > b);//true
        System.out.println(a < b);//false
        System.out.println(a <= b);//false
        System.out.println(a >= b);//true
    }
}

5.4 逻辑运算符

/*
 *逻辑运算符：
 *   & ：前后都为true，结果才为true
 *   | :有true，结果就为true
 *   ! :非 取反  true为false。 false为true
 *   ^ ：相同为false  不同为true
 *
 * */
public class LogicTest {
    public static void main(String[] args) {
        boolean b1 = true;
        boolean b2 = true;
        boolean b3 = false ,b4 = false;

        System.out.println("-------- &与 ---------");
        System.out.println(b1 & b2 & b3);

        System.out.println("-------- |或 ---------");
        System.out.println(b1 | b2 | b3);
        System.out.println(b1 | b4 | b3);

        System.out.println("--------- !非 --------");
        System.out.println(!b1);//取反 false
        System.out.println(!b3);//取反 true
        System.out.println(!(b1 | b4 | b3));//false

        System.out.println("--------- ^异或 --------");
        System.out.println(b1 ^ b2);
        System.out.println(b1 ^ b3);
        System.out.println(b3 ^ b4);

        System.out.println("============ ");
        System.out.println(3 > 2 & 1>3);//false
        System.out.println(3 > 2 | 1>3);//true
        System.out.println(3 > 2 ^ 1>3);//true
    }
}

开发原则：逻辑的判断用&& ||

/*
 *逻辑运算符：
 *   & ：前后都为true，结果才为true
 *       &前面的表达式为false，后续的仍会执行
 *   | :有true，结果就为true
 *      |前面的表达式是true，后续的仍然会执行
 *   ! :非 取反  true为false。 false为true
 *   ^ ：相同为false  不同为true
 * ------------------
 *  &&：短路与
 *       如果&&前面的表达式是false，则后续的不再执行。
 *  ||：短路或
 *      如果||前面的表达式是true，则后续的不再执行
 * */
public class LogicTest2 {
    public static void main(String[] args) {
        boolean b1 = true;
        boolean b2 = true;
        boolean b3 = false ,b4 = false;

        System.out.println("-------- && 短路与 --------");
//        System.out.println(b1 && b2 && b4);//false
        int m = 10,n=20;
//        boolean result = m > n & ++m < n;

        boolean result = m > n && ++m < n;
        System.out.println("result = " + result+",m="+m);

        System.out.println("---------- || 短路或 ---------");
//        System.out.println(b3 | b4 | b1);

        int a = 10,b=20;
//        boolean flag = a<b | ++a >b;  //不短路
        boolean flag = a<b || ++a >b;   //短路
        System.out.println("flag = " + flag+",a="+a);

    }
}

5.5 条件运算符

/*
 * 条件运算符/三元运算符/三目运算符
 * 表达式1?表达式2:表达式3;
 * x?y:z
 *   y :true --->x
 *   z :false ---> x
 * */
public class TjTest {
    public static void main(String[] args) {
        int age = 16;
        //                 x      y       z
        //          boolean表达式 true     false
        String result = age > 18 ? "已成年" : "未成年";
        System.out.println("result = " + result);

        boolean isMarry = true;
//        String str = isMarry == true ?"已婚":"未婚";
        String str = isMarry ? "已婚" : "未婚";
        System.out.println("str = " + str);

        int a = 100;
        int b = 200;

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

小练习

public class TjTest2 {
    public static void main(String[] args) {
        /*
         * 求三个数中 最大的。
         * */
        int a = 1000, b = 200, c = 50;
        //获取前两个数中最大值。
        /*int max1 = a>b? a:b;
        //再用最大值和第三个值做比较
        int max2 = max1 > c?max1:c;
        System.out.println("max2 = " + max2);*/

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


    }
}

5.6 位运算符

/*
* &:上下都为1，结果为1
* |:上下有1，则为1
* ^:上下相同为0，不同为1
* ~:1变0 0变1 取反  补码
* 负整数先算出来补码， 正整数的三码合一
*
* &
*   1.前后都是boolean 是逻辑运算符
*   2.前后都是整数，是位运算符
*
* */
public class BitTest {
    public static void main(String[] args) {
        /*
        * 1 0 1
        * 0 1 1
        *       &
        * ------
        * 0 0 1 = 1
        * */
        System.out.println(5 & 3);
        /*
         * 1 0 1
         * 0 1 1
         *       |
         * ------
         * 1 1 1 = 7
         * */
        System.out.println(5 | 3);
        /*
         * 1 0 1
         * 0 1 1
         *       ^
         * ------
         * 1 1 0 = 6
         * */
        System.out.println(5 ^ 3);
        /*
        * 0000 0101
        * 1111 1010 = -6
        * */
        System.out.println(~5);
        /*
        * 1000 0101 原码
        * 1111 1010 反码
        * 1111 1011 补码
        * 0000 0011
        * 0000 0011 3
        * */
        System.out.println(-5 & 3);
    }
}


/*
* << 左移  *2^位移数方
* >> 右移  /2^位移数方 正数空缺位补0   负数空缺位补1
*
* >>> 无符号右移  ：无论正负数，空缺位都补0
*       0
*       1
* */
public class BitTest2 {
    public static void main(String[] args) {
        System.out.println("-------- << --------");
        System.out.println(4);//0100
        System.out.println(4 << 1);//1000
        System.out.println(4 << 2);//0001 0000
        System.out.println(4 << 3);//0010 0000

        System.out.println("-------- >> --------");
        System.out.println(16);//10000
        System.out.println(16 >> 1);//1000
        System.out.println(16 >> 2);//100
        System.out.println(16 >> 3);//10
        //1110 1111 1111 0000
        System.out.println(-16 >> 1);//1111 0000 >> 1111 1000
        System.out.println(-16 >> 3);

        System.out.println("--------- >>> ---------");
        //0000 0000 0000 0000 0000 0000 1001 0000
        System.out.println(0b00000000000000000000000000010000);
        //10000000000000000000000000010000
        //11111111111111111111111111101111
        //11111111111111111111111111110000
        System.out.println(0b11111111111111111111111111110000);
        //11111111111111111111111111110000 >>> 1
        //01111111111111111111111111111000
        System.out.println(0b01111111111111111111111111111000);
        System.out.println(-16 >>> 1);

    }
}

5.7 运算符优先级

优先级运算符说明Java运算符
1括号()、[]、{}
2正负号+、-
3单元运算符++、--、~、！
4乘法、除法、求余*、/、%
5加法、减法+、-
6移位运算符<<、>>、>>>
7关系运算符<、<=、>=、>、instanceof
8等价运算符==、!=
9按位与&
10按位异或^
11按位或`
12条件与&&
13条件或`
14三元运算符? :
15赋值运算符=、+=、-=、*=、/=、%=
16位赋值运算符&=、`
package com.atguigu.a_operator;
/*
* 运算符优先级：不要记那些运算符优先。
*   想优先执行的，加()
* ()会提高代码的可读性
* 注意：表达式不要太长！
* */
public class OperatorYxjTest {
    public static void main(String[] args) {
        int num = 6;

        int result = num + (10 >> 1);

        System.out.println("result = " + result);

        int a = 1000, b = 200, c = 50;

        int max = a > b ? (a > c ? a : c) : (b > c ? b : c);
        System.out.println("max = " + max);
    }
}

六、package 包、import 关键字

6.1 package 包

  • 概念：为了存储具有层级的类。
    • 同包下不能有同名的类。但是不同包下可以有同名的类。

6.2 在IDEA中创建包

在这里插入图片描述

创建包的时候，层级的分割用. ，比如：com.atguigu.shop.order 四级目录

  • 一个源文件只能有一个声明包的package语句
  • package语句作为Java源文件的第一条语句出现。若缺省该语句，则指定为无名包。
  • 包名，属于标识符，满足标识符命名的规则和规范（全部小写）、见名知意
    • 包通常使用所在公司域名的倒置：com.atguigu.xxx。
    • 大家取包名时不要使用"java.xx"包
  • 包对应于文件系统的目录，package语句中用 “.” 来指明包(目录)的层次，每.一次就表示一层文件目录。
  • 同一个包下可以声明多个结构（类、接口），但是不能定义同名的结构（类、接口）。不同的包下可以定义同名的结构（类、接口）

6.3 包的层级显示

在这里插入图片描述

6.4 import导入

  • 语法：
    • import 包名.类名;
  • 书写位置：
    • 包的下方，类的上方。
  • 在这里插入图片描述

6.5 导包的注意事项

  • import语句，声明在包的声明和类的声明之间。

  • 如果需要导入多个类或接口，那么就并列显式多个import语句即可

  • 如果使用a.*导入结构，表示可以导入a包下的所有的结构。举例：可以使用java.util.*的方式，一次性导入util包下所有的类或接口。

  • 如果导入的类或接口是java.lang包下的，或者是当前包下的，则可以省略此import语句。

  • 如果已经导入java.a包下的类，那么如果需要使用a包的子包下的类的话，仍然需要导入。

  • 如果在代码中使用不同包下的同名的类，那么就需要使用类的全类名的方式指明调用的是哪个类。（后续再说）

  • （了解）import static组合的使用：调用指定类或接口下的静态的属性或方法(后续再说)

七、Scanner 扫描仪 键盘输入功能

7.1 Scanner作用

在控制台，让用户输入数据。

作为一个技术的过度。后期我们会学习前端技术，就有页面提供用户输入数据。

7.2 Scanner的使用步骤

  1. 导包：import java.util.Scanner;
  2. 创建对象：Scanner input = new Scanner(System.in);
  3. 调用方法：根据要输入的数据类型，调用对应的方法。
  4. 释放资源：input.close();
package com.atguigu.b_scanner;
//        1. 导包：import java.util.Scanner;
import java.util.Scanner;
/*
* 1. 导包：import java.util.Scanner;
2. 创建对象：Scanner input  = new Scanner(System.in);
3. 调用方法：根据要输入的数据类型，调用对应的方法。
4. 释放资源：input.close();
*
* */
public class BaseScannerTest {
    public static void main(String[] args) {
//        2. 创建对象：Scanner input  = new Scanner(System.in);
        Scanner input = new Scanner(System.in);

//        3. 调用方法：根据要输入的数据类型，调用对应的方法。
        System.out.println("请输入年龄：");
        int age = input.nextInt();

        System.out.println("age = " + age);
//        4. 释放资源：input.close();
        input.close();
    }
}

八、Math

package com.atguigu.c_math;
/*
* Math是Jdk提供的一个工具类。
* Math在java.lang包下，是可以省略导包的。
* Math是无需创建对象，可以使用类名直接调用方法。
* Math里所有的方法都和数学有关
* */
public class MathTest {
    public static void main(String[] args) {
        /*double sqrt = Math.sqrt(9);
        System.out.println("sqrt = " + sqrt);
        int abs = Math.abs(-8);
        System.out.println("abs = " + abs);*/

        //random()方法默认生成的是0.0<= x <1的数据
        //指定一个公式，获取我们自定义范围内的整数。
        //[0.0,1)
        //[5,30)   [m,n)
        //Math.random()*(n-m+1)+m;
        //Math.random()*(30-5+1)+5;
        double random = Math.random();
        System.out.println("random = " + random);
        int i = 1;
        while(i<=50){
            int result = (int)(Math.random()*(30-5+1)+5);
            System.out.println("result = " + result);
            i++;
        }

    }
}
zxxs123321
关注
  • 12
    点赞
  • 踩
  • 13
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
第二节.初识变量及运算符
m0_68460470的博客
03-26 309
Java基础
Java编程语言变量和数据类型及运算符
Super风筝的博客
02-12 315
先带大家了解下计算机内存的分类： 1.RAM：运行时存储 我们的计算机程序在运行的时候 数据就会临时存储在RAM中。 如果不持久化，或者突然断电，它的数据就会丢失了。 2.RAM：只读存储，可持久化存储 文件存储 1.什么是变量？ 变量：可以改变的量，在java程序中，会将数据以圈占地盘的形式存储起来，因为如果要真正的要找变量，如果依靠内存地址，非常的繁琐，于是我们就给变量取了个名字（变量）。 类...
Java 变量，数据类型，运算符
m0_62420605的博客
10-11 254
Java 变量，数据类型，运算符（Java基础）
Java第二课. 数据类型与运算符
zhuang15的博客
11-25 391
1 Java第二课 1.1 回顾: 1. java发展历史,95 09 ,java平台:javaSE(标准版) javaEE(企业版) javaME(微型版) 2. Java语言的特点:面向对象,跨平台(字节码文件->不同的平台上有不同的虚拟机,虚拟机解释字节码文件),健壮性(强类型,取消指针,不用强制回收对象),分布式,多线程,动态性等 3. Jdk,jre jvm三者关系 (jdk>jre>jvm) 4. Jdk的安装和环境配置 5. IDE工具Eclipse: 工具的配置与使
第二章 变量、数据类型和运算符
穆雄雄的博客
12-18 376
一、变量： 1.根据数据类型在内存中分配一个合适的空间并给他命名，即“变量名” 2.将数据存储到这个空间中， 3.从空间中取出数据，可以使用变量名来获得。 二、java中的数据类型 数据类型： 1.数值类型 （1）整型 int （2）非整型 double float 2.非数值类型 （1）字符 char （2）字符串类型 String 三、使用变量的步骤： 1.声明变量： 变量类型 变量名; 2...
第二节 变量、数据类型、运算符
qq_45656601的博客
03-17 541
** 变量、数据类型、运算符 ** 标识符是用来给变量、类、方法以及包进行命名的。4大规则： 必须以字母、下划线_、美元符号开头。其它部分可以是字母、下划线“”、美元符“开头。 其它部分可以是字母、下划线“_”、美元符“开头。其它部分可以是字母、下划线“”​、美元符“”和数字的任意组合。 大小写敏感，且长度无限制。 不可以是Java的关键字。 标识符的使用规范 表示类名的标识符：每个单词的首字母大写，如Man, GoodMan 表示方法和变量的标识符：第一个单词小写，从第二个单词开始首字母大写，我们称之为“
Java中的变量和数据类型&运算符
weixin_43400205的博客
07-06 249
变量 变量的作用：用来储存数据 变量命名的规范：字下美人数 骆驼 有意义（可以使用以字母、下划线、美元符号、人民币符号开头，不能以数字开头，可以包含数字，严格遵照驼峰命名法，并且要有意义 ） 驼峰命名法：首字母小写后面的单词首字母大写 例如：nameOfStudent、ageOfTeacher 八大数据类型： （整数型）byte short in long(byte的取值范围为-128----+1...
2.数据类型与运算符
weixin_49165958的博客
07-08 164
变量的命名变量:程序运行期间，内容可以发生改变的量。 变量:程序运行期间，内容可以发生改变的量。 一、变量命名规则： 字下美人数、骆驼、有意义 字：字母az，AZ 下：下划线- 美：美元符号$ 人：人民币符号￥ 数：数字0~9 注释：1、不能以数字开头 2、变量名组成是由字下美人数 组成 骆驼：驼峰命名法，如className，schoolAddress，一般开头不用大写字母,后续的完整词组首字母要大写，与类名区分。 二、变量的数据类型 .1数值型 整形：byte（-128~127 -2的七次方~2的七
二.变量，数据类型
PangtouFish的博客
06-17 187
二.变量，数据类型 变量 一个数据存储空间的表示 不同的数据会存入不同的内存空间，并相互独立 变量—变量名—变量类型—变量值 变量名命名规则 只能以（字，下，美，人）开头不能以数字开头 1.英文字母（多个单词组成时，首字母小写，其后每个单词的首字母大写） 例如：myFirstName 2.下划线______ 3.美元符号 $ 4.人民币符号￥ 5.数字 6.有意义，不要取（a,b,aaa,bbb）...
第二章变量、数据类型和运算符
ddd_22的博客
03-01 63
变量、数据类型和运算符
第02章.数据类型和运算符2.pdf
12-01
在本章中，我们详细介绍了 Java 中的数据类型和运算符，包括标识符、数据类型分类、整型、浮点型、字符型、布尔型、常量和变量、运算符等。这些知识点是 Java 编程语言的基础，理解这些概念对 Java 编程非常重要。
2.数据类型和运算符作业答案-1
08-08
总的来说，这个作业涵盖了Java编程的基础知识，包括数据类型、运算符、输入输出、数学运算、格式化输出以及类和方法的使用。这些都是编写任何Java程序的基础。理解并熟练掌握这些概念对于进一步学习Java的高级特性，...
推荐优质Java课程 疯狂Java语言编程 Java入门到进阶教程 03.数据类型和运算符（共19页）.ppt
12-19
对于初学者来说，了解Java的基础至关重要，包括数据类型和运算符。本篇内容将深入探讨这些基础知识。 首先，Java中的注释是程序员用来解释代码的重要工具。单行注释以"//"开始，多行注释使用"/*...*/"包围，而文档...
第二章 数据类型与运算符 （一）1
08-03
本文将详细阐述数据类型、变量、运算符以及如何在Java中进行输入输出。 首先，数据类型是定义变量所能存储信息类型的分类。在Java中，主要分为两大类：基本数据类型和引用数据类型。基本数据类型包括整型（byte、...
数据类型与运算符
12-11
本章节主要探讨了 Java 中的基础概念，包括变量、数据类型、运算符以及如何从键盘接收输入。 1. 变量：变量是程序中最基本的存储单元，用于存储数据。在Java中，变量包括三个要素：变量值、变量类型和变量名。变量...
springboot民办高校科研项目管理系统-计算机毕业设计源码54009
VX_DZbishe的博客
08-11 474
论文主要是对基于springboot的民办高校科研项目管理系统进行了介绍，包括研究的现状，还有涉及的开发背景，然后还对系统的设计目标进行了论述，还有系统的需求以及整个的设计方案，对系统的设计以及实现，也都论述的比较细致，最后对基于springboot的民办高校科研项目管理系统进行了一些具体测试。本次报告，首先分析了研究的背景、作用、意义，为研究工作的合理性打下了基础。
SpringBoot快速入门（手动创建）
m0_74124657的博客
08-11 406
代码如下//引导类项目的入口//注解添加导入进来你可以浏览器中查看自己编写的代码，看是否正确localhost：你命名的端口号（默认是8080。后面你也可以在配置文件修改）
集合（1）
最新发布
supercool7的博客
08-12 761
表示不同的类型集合，Collection、Map、List、Set、Queue、Deque等，以及辅助性质的接口Iterator、LinkIterator、Comparator、Comparable这些接口是为迭代和比较元素而准备。对接口的具体实现，主要常用的有：ArrayList、LinkedList、HashMap、HashSet、TreeMap等等。理解Java集合体系可以从三个层次：最上层的接口、中间的抽象类、最后的实现类。是所有集合框架的根接口，包含了对集合进行基本操作的方法。
反射和注解
supercool7的博客
08-08 296
反射的基本步骤包括获取Class对象、获取类的信息（构造函数、方法、字段等），然后通过Constructor、Method、Field等类的实例进行具体的操作。注解以@符号开头，通常紧跟着一个标识符，后面可以跟一些参数，用于给类、方法、字段等添加元数据信息，这些信息可以在编译时、运行时被读取和处理。通过Class类，可以获取类的构造函数、方法、字段等信息，而不需要在编译时确定这些信息。Spring、SpringBoot、Mybatis等框架中都大量使用了反射机制。此外，开发者还可以定义自己的注解，通过。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值