变量、数据类型和运算符

最新推荐文章于 2022-11-11 20:07:13 发布

玉龙1989

最新推荐文章于 2022-11-11 20:07:13 发布

阅读量531

点赞数

分类专栏：基础

本文链接：https://blog.csdn.net/weixin_38955858/article/details/77829236

版权

基础专栏收录该内容

30 篇文章 0 订阅

订阅专栏

1. 变量、数据类型和运算符

1.1. 什么是内存？

如果开启的程序太多（.exe），计算机会卡。因为每一个运行的程序，都需要占用一定的内存。比方开1个记事本，如果没保存，断电了，数据会丢失。当时编辑的时候，数据就是保存在内存里的。

1.2. 容量单位

1eb(艾字节) = 1024Pb(拍字节)

1Pb(拍字节) = 1024Tb(太字节)

1Tb(太字节) = 1024Gb(千兆字节)

1Gb (千兆字节)= 1024Mb（兆字节）

1Mb（兆字节） = 1024Kb(千字节)

1Kb(千字节) = 1024Byte(字节)

1Byte(字节)=8bit(比特)

1bit(比特) = 1个二进制位0或1

Java采用Unicode编码（支持中文），1个英文字母= 1Byte(字节)=8位，1个汉字=2Byte(字节)=16位

1.3. 内存如何存储数据？

宾馆住宿，

找一个宾馆：开辟一块内存

房间：内存中的一个变量

房间类型（单人间，双人间，家庭套房）：变量的类型,存储1个整数和存储一个浮点数（带小数的数），需要的内存空间也不一样。

房间号（几楼的几零几房间的名称）：变量名 int a =10; 为什么要取变量名？（因为计算机中的内存地址01110111….二进制的字符串，非常的不好记忆，所以给变量起个别名，方便记忆和使用）

(房间的真正的地址：东经183.5度，北纬45.8度，但是这个地址非常的不好记，所以也要给房间起别名，记忆房间号方便)

房间里住的人：变量中存储的值

1.4. 数据类型有哪些？

最高位是符号位，表示正负。

基本数据类型(8个)：

整数

byte 1个字节 8位取值范围： -128------127 -2的7次方 ---2的7次方-1

short 2个字节取值范围：-32768-----32767 ， -2的15次方----2的15次方-1

int 4个字节取值范围： -2的31次方---2的31次方-1

long 8个字节取值范围：-2的63次方----2的63次方-1

浮点数：

float(单精度的浮点数): 4个字节取值范围：1.4E-45(1.4乘以10的-45次方) ---- 3.4028235E38（3.4028235乘以10的38次方）正负都可以取

double(双精度的浮点数：) 8个字节取值范围: 4.9E-324（4.9乘以10的-324次方）-----1.7976931348623157E308（接近1.8乘以10的308次方，非常大），正负都可以取

字符类型：

char 2个字节单引号

char sex =’男‘； char可以看成一种特殊的整型。 int num = 20; char zifu = num;

布尔类型（逻辑值，只能是真或假，取值只能是true 或者false）

boolean 1位 1/8个字节

注意：java编译环境中，写1个整数，默认类型是int ，写1个浮点数，默认类型是double

byte num1 = 10; int num2=20; float num3=3.5f; float num4 = 3.5F; double num5 = 2.3; double num6 = 2.3d; double num7 = 2.3D;

引用数据类型：

String 字符串双引号描述一段话 String sayStr = “今天吃了10个包子”;

数组

接口

类

例题1：

/**

* 8大基本数据类型

* 测试各个类型的取值范围

* 变量的声明及使用方式1

* @author Administrator

public class Test01 {

public static void main(String[] args) {

//byte

System.out.println(Byte.MIN_VALUE);

System.out.println(Byte.MAX_VALUE);

//short

System.out.println(Short.MIN_VALUE);

System.out.println(Short.MAX_VALUE);

//float

System.out.println(Float.MIN_VALUE);

System.out.println(Float.MAX_VALUE);

//int -2147483648----- 2147483647

System.out.println("**"+Integer.MIN_VALUE);

System.out.println("**"+Integer.MAX_VALUE);

//double

System.out.println(Double.MIN_VALUE);

System.out.println(Double.MAX_VALUE);

//默认类型int 默认类型是double

System.out.println(10);

System.out.println(3.5);

//举例类型变量名 = 具体的值

int num1 = 10;

//byte的范围是-128---127，只能在该范围内存储byte类型的数，不能超出范围

byte num2 = -128;

//显式的声明1个长整型的数，加后缀"L" long num3 = 199L;

long num3 = 2147483648L;

System.out.println("num3="+num3+"\t num2="+num2+"\t num1="+num1);

//显式的声明1个float类型的数，加后缀"f"或者"F"

float num4 = -3.4f;

float num5 = 3.56F;

//声明1个double类型的数，可以加后缀”d“或者”D“，后缀可以省略

double num6 = 3.5;

double num7 = 3.5d;

double num8 =3.5D;

//下面编译出错，因为short的范围是-32768---32767，超出了存储范围，编译器认为把int类型的数强制赋值给了short类型

//short num9 = 32768;

//char字符类型

//描述性别单引号

char sex='男';

//描述电灯的开，关

char status ='开';

//布尔类型，表示真或者假取值只能在2个里选1个

boolean flag1 =true;

boolean flag2 =false;

}

例题2：

/**

* AscII码表中，有几个特殊的值需要记忆

* char可以看成一种特殊的整型

* A --->65 B-->66,.... a-->97 b=98.... 字符‘0’--->48,字符‘1’ = 49 ,字符‘9’ = 57

* @author Administrator

public class Test08 {

public static void main(String[] args) {

//20是int类型，赋值给char类型的

char num=20;

//字符类型，单个字符

char zifu1 = 'A';

//声明1个整数int类型的num2，然后强制转换成char类型的，赋值给char变量zifu2

int num2 = 69;

char zifu2 = (char)num2;

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

//字符 ‘0’

char zifu3 = '8';

int num3 = zifu3;

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

//字符 ‘F'

char zifu4 = 'F';

int num4 = zifu4;

System.out.println("num4="+num4);//70

}

1.5. 变量的使用步骤

方式1：声明并且赋值数据类型变量名=具体的值；

int num1 = 10;

System.out.println(“num1=”+num1);

方式2：先声明，再赋值数据类型变量名；变量名=具体的值;

int num1; num1 = 10; System.out.println(“num1=”+num1);

注意：1行可以声明多个变量

例题1：

package com.njwb.variable;

/**

* 变量的声明及使用方式2

* @author Administrator

public class Test03 {

public static void main(String[] args) {

//1.先声明

int num1;

//2.再赋值

num1=20;

//3.使用

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

//1行声明多个变量

int num2,num3,num4;

//给多个变量赋值

num2 = 10;

num3 = 20;

num4 = 30;

System.out.println("num2="+num2+" num3="+num3+" num4="+num4);

//1行声明多个变量，同时赋值

int num5=15,num6=17,num7=18;

System.out.println("num5="+num5+" num6="+num6+" num7="+num7);

}

1.6. 变量命名规则

1．只能是数字，字母，下划线“_”,美元符号“$”,不能以数字开头。

2．变量名不能是系统关键字

3．变量名应尽量做到见名知意，要有意义

4．变量名通常第1个单词以小写字母开头，其余单词的首字母大写

例题1

/**

* 变量的命名

* @author Administrator

public class Test04 {

public static void main(String[] args) {

int $24a;

//不能以数字开头

//int 5anum;

//变量的组成：字母，数字，_ ,$

//int au%a;

int my_score;

int _78a;

//正确的，只是不推荐，一般第1个单词首字母小写，其余单词的首字母大写

int COUNT;

//正确的，只是这样的命名不好，a,b,c可读性差

int a,b,c;

//这样的有意义，推荐

int javaScore,htmlScore,sqlScore;

//不能是系统的关键字编译器中红色的字体

//int void;

}

1.7. 变量使用练习

使用变量存储以下MP3信息，并打印输出

品牌（brand）：爱国者F928

重量（weight）：12.4

电池类型（type）：内置锂电池

价格（price）：499

分析： String brand=”爱国者F928”; double weight=12.4; String type = “内置锂电池”; int price = 499;

1.8. 赋值运算符

= ， +=，-=，*=， /=, %=

变量名 =值，将右边的值赋值给左边的变量。

/**

* 赋值运算符的使用 +=, *= /= , %=, -=,

* @author Administrator

public class Test06 {

public static void main(String[] args) {

// +=

int num1 = 10,num2=20,num3=30;

//以下2句代码等价

//num1 = num1+num3;

num1 += num3;

System.out.println("num1="+num1);//40

// *=

//num1 = num1*num2;

num1 *= num2;

System.out.println("num1="+num1);//800

// %= 800%30的余数整数余数

//num1 = num1%num3;

num1 %= num3;

System.out.println("num1="+num1);//20

// /= 整数商

//num1 = num1/num2;

num1 /= num2;

System.out.println("num1="+num1);//1

// -=

//num1 = num1 - num2;

num1 -= num2;

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

}

赋值运算符练习：交换变量的数据

/**

* 交换2个变量的值

* @author Administrator

public class Test07 {

public static void main(String[] args) {

//声明第3个变量temp，拥有存储交换的值

int a =10,b=20,temp=0;

System.out.println("交换前：a="+a+",b="+b);

temp = a;

a = b;

b = temp;

System.out.println("交换后：a="+a+",b="+b);

}

1.9. 算术运算符

一元（单目）运算符有且只有一个运算参数，二元（双目）运算符有且只有两个运算参数。

二元运算符：+（加）、-（减）、*（乘）、/（求商）、%（求余）

见以上赋值运算符的例子

一元运算符：+（正），-（负），++（自增），--（自减）

int num1 = 10; int num2 = -20;

前自增表达式等于自增之后的值后自增表达式等于自增之前的值不管是前自增，还是后自增，变量的值最后都会加1

前自减表达式等于自减之后的值后自减表达式等于自减之前的值不管是前自减，还是后自减，变量的值都会减1

例题1

/**

* 自增

* @author Administrator

public class Test09 {

public static void main(String[] args) {

int num1 = 10;

//num1 = num1+1;

//num1++;

//++num1;

System.out.println("++num1该表达式的值："+(++num1));

//System.out.println("num1++该表达式的值："+(num1++));

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

}

例题2：

/**

* 自减

* @author Administrator

public class Test10 {

public static void main(String[] args) {

int num1 = 20;

//num1 = num1-1;

//num1--;

//--num1;

System.out.println("--num1该表达式的值："+(--num1));

//System.out.println("num1--该表达式的值："+(num1--));

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

}

例题3：

/**

* 自增 ,自减的练习

* @author Administrator

public class Test11 {

public static void main(String[] args) {

int num1 = 10;

++num1; //num1=11

num1++; //num1=12

num1-=45;//num1=-33;

--num1;//num1=-34;

num1--;//num1=-35;

--num1;//num1=-36;

--num1;//num1=-37;

System.out.println("--num1该表达式的值"+(--num1));

num1+=20;//num1=-17;

num1++;//num1=-16;

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

}

1.10. Scanner接收int输入，String输入

package com.njwb.input;

import java.util.Scanner;

/**

* 键盘输入的步骤

* 1.导包 import java.util.Scanner;或者 java.util.*;(表示引用java.util下面的所有的类)

* 2.声明实例化键盘端输入的实例变量Scanner变量

* 3.提示信息（提示用户输入），借助nextXXX()方法输入对应的类型的值

* nextInt(),nextShort(),nextFloat() ,nextDouble().... nextLine()

* 导包的方式： 1.编译有误，点击出错行的行号的左侧，点击提示信息

* 2.ctrl+shift+o(字母o) 再按enter回车(推荐)

* 3.在Scanner附近，出现黄色的提示信息，点击import

* 4.把光标定位到Scanner附近，按alt+ /

* @author Administrator

public class Test01 {

public static void main(String[] args) {

//实例化输入变量

Scanner input = new Scanner(System.in);

//借助nextXXX()方法输入

/*System.out.print("请输入一个整数：");

//接收整数值

int num1 = input.nextInt();

System.out.println("你输入的整数值为:"+num1);

//接收单精度的浮点数

System.out.print("请输入一个float的浮点数：");

float num2 = input.nextFloat();

System.out.println("你输入的单精度浮点数为："+num2);

//接收双精度的浮点数

System.out.print("请输入一个double类型的的浮点数：");

double num3 = input.nextDouble();

System.out.println("你输入的双精度浮点数为："+num3);*/

//接收字符串

System.out.print("请输入一个字符串：");

String str = input.next();

System.out.println("你输入的字符串为："+str);

//接收字符串中，字符串中想出现空格

input = new Scanner(System.in);

System.out.print("请输入一个字符串：");

String str2 = input.nextLine();

System.out.println("你输入的字符串为："+str2);

}

1.11. Scanner+算数运算符练习

从控制台接收三门课的成绩，并计算平均分。

//声明3个变量，用于存储3门功课的成绩，声明1个变量。用于存储总分

int score1,score2,score3; int sum = 0;

//运行截图：请输入第一门功课的成绩： 80

请输入第2门功课的成绩： 80

请输入第3门功课的成绩： 80

3门功课的平均分为：80 sum/3

package com.njwb.input;

import java.text.DecimalFormat;

import java.util.Scanner;

/**

* 计算3门功课的平均分

* @author Administrator

public class TestAvg {

public static void main(String[] args) {

//声明3个变量，用于存储成绩

double score1,score2,score3;

//声明第4个变量，用于累加总成绩

double sum = 0;

Scanner input = new Scanner(System.in);

System.out.print("请输入第1门功课成绩：");

score1 = input.nextDouble();

System.out.print("请输入第2门功课成绩：");

score2 = input.nextDouble();

System.out.print("请输入第3门功课成绩：");

score3 = input.nextDouble();

//计算3门功课的平均分，打印输出

sum = score1+score2+score3;

//保留2位小数

System.out.println("3门功课的平均分为："+new DecimalFormat("#.00").format(sum/3));

}

1.12. 保留指定位数的小数

package com.njwb.input;

import java.math.BigDecimal;

import java.text.DecimalFormat;

/**

* 如何保留指定位数的小数

* @author Administrator

public class Test02 {

public static void main(String[] args) {

//保留3位小数3.142

double pi = 3.1415926;

//方式1： java.text.DecimalFormat 保留几位小数，就是几个’0‘

DecimalFormat df = new DecimalFormat("#.000");

//借助DecimalFormat类提供的方法，转换成保留3位小数的字符串num1Str = “3.142”

String num1Str = df.format(pi);

//将字符串转换double基本数据类型

double num1 = Double.valueOf(num1Str).doubleValue();

System.out.println("处理后num1="+num1);

//方式2: Math.round() 3141.5926--> 3142 --> 3.142

//System.out.println(Math.round(pi*1000)); //3142

double num2 = Math.round(pi*1000)/1000.0;

System.out.println("处理后num2="+num2);

//方式3：

BigDecimal bg = new BigDecimal(pi);

double num3 = bg.setScale(3, BigDecimal.ROUND_HALF_UP).doubleValue();

System.out.println("处理后num3="+num3);

//方式4： %表示小数点前任意位数的整数 3表示小数的位数 f表示是浮点类型

String num4Str = String.format("%.3f", pi);

double num4 = Double.valueOf(num4Str).doubleValue();

System.out.println("处理后num4="+num4);

}

更改jdk，选择新版本，选中JRE System Library(工程的最下方的类库) ,右击 properties --- Execution environment选择 SunJDK 1.6.0_13版本

1.13. 数据类型转换

自动类型转换：取值范围小的变量赋值给取值范围大的变量。

byte-àshort-àint-àlong-àfloat-àdouble 从左往右自动类型转换

char-àint-àlongàfloat-àdouble 从左往右自动类型转换

强制类型转换：取值范围大的变量赋值给取值范围小的变量

上面2条线，如果从右往左，转换，就需要强制类型转换。

例题1：

//将取值范围小的，赋值给取值范围大的，ok

short num1 = 10;

int num2 = num1;

//反过来，将取值范围大的，赋值给取值范围小的，出现问题,如何解决，强制类型转换（）

num1 = (short)num2;

//自动类型转换

char zifu = 'a';

int num3 = zifu;

//反过来需要强制类型转换

zifu =(char)num3;

强制转换练习

例题2

去年Apple笔记本所占市场份额是20，今年增长的市场份额是9.8，求今年所占份额？

//声明1个变量表示原有的市场份额

int rate = 20;

double increaseRate = 9.8;

//现有的份额 int和double做运算，整个表达式会被提升成大的数据类型（double）

rate = (int)(rate+increaseRate);

System.out.println("今年所占份额为："+rate);

1.14. 关系运算符

>(大于)、<（小于）、==（等于）、!=（不等于）、 >=(大于等于)，<=(小于等于) 用关系运算符运算的表达式，返回值是boolean类型，要么true，false

int num1=10,num2=20;

System.out.println(num1>num2);

System.out.println(num1<num2);

System.out.println("num1是否小于等于num2:"+(num1<=num2));

//判断2个数是否相等

System.out.println("num1是否等于num2:"+(num1==num2));

//判断2个数是否不等，如果不等返回true，否则返回false

System.out.println("num1是否不等于num2:"+(num1!=num2));

练习：在控制台分别输入两个数字，如果第一次输入的大于第二次输入的数字，输出true

Scanner input = new Scanner(System.in);

System.out.print("请输入第1个整数：");

int num3 = input.nextInt();

System.out.print("请输入第2个整数：");

int num4 = input.nextInt();

System.out.println("第一个数是否大于等2个数"+(num3>num4));

1.15. 逻辑运算符

&& 逻辑与 || 逻辑|| ！取反

表达式1&&表达式2 如果表达式1为真，表达式2也为真，那么整个表达式才为真，如果表达式1为假，表达式2不用计算

表达式1 || 表达式2 2个表达式，只要有1个为真，那么整个表达式就为真如果表达式1为真，那么表达式2不用计算

！表达式1 假设表达式为假，取反后为真。假设表达式1为真，那么取反后为假。

/**

* 逻辑运算 && || ！

* @author Administrator

public class Test03 {

public static void main(String[] args) {

int num1 = 10 ,num2 = 20,num3=30,num4 = 50;

System.out.println("=========与==========");

//&&

//true

System.out.println((num1<num2) && (num3<num4));

//false

System.out.println((num1>num2) && (num3<num4));

//false 表达式2不会执行

System.out.println((num1>num2) && (++num3<10));

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

System.out.println("=========或==========");

//true

System.out.println((num1<num2) || (num3<num4));

// 表达式1，表达式2都为假，整个表达式为假 false

System.out.println((num1>num2) || (num3>num4));

//表达式1为真，表达式2不会执行 true

System.out.println((num1<num2) || (++num3<10));

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

//表达式1为假时，表达式2才会执行 true

System.out.println((num1>num2) || (++num3>10));

System.out.println("2次处理后：num3="+num3);

//取反

System.out.println("=========取反==========");

//true

System.out.println( "num1是否小于num2 : "+(num1<num2));

//false

System.out.println( "num1是否小于num2 : "+!(num1<num2));

}

& 与 |或

表达式1&表达式2 如果表达式1为真，表达式2也为真，那么整个表达式才为真，如果表达式1为假，表达式2也需要计算（不管表达式1为真还是假，表达式2都需要计算）

表达式1 |表达式2 2个表达式，只要有1个为真，那么整个表达式就为真如果表达式1为真，那么表达式2也需要计算（不管表达式1为真还是假，表达式2都需要计算）

/**

* &

* |

* @author Administrator

public class Test04 {

public static void main(String[] args) {

int num1 = 10,num2=20,num3=30,num4=50;

System.out.println("=============与==============");

//true

System.out.println((num1<num2) & (num3<num4));

//false

System.out.println((num1>num2) & (num3<num4));

//不管表达式1为真还是假，表达式2都需要计算 false

System.out.println((num1>num2) & (++num3>10));

//31

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

System.out.println("=============或==============");

//true

System.out.println((num1<num2) | (num3<num4));

//true

System.out.println((num1>num2) | (num3<num4));

//false 2个表达式都为假，整个表达式为假

System.out.println((num1>num2) | (num3>num4));

//true 虽然表达式1为假，但是表达式2还是要执行的

System.out.println((num1>num2) | (num3++>10));

System.out.println("num3="+num3);//32

//true 虽然表达式1为真，但是表达式2还是要执行的

System.out.println((num1<num2) | (num3++>10));

//33

System.out.println("2次处理后num3="+num3);//

}

考试考了75分，70~80算良好。

<< 左移 1位，相当于乘以2 ，左移2位，乘以2的平方，左移3位，乘以2的3次方 ……

>> 右移1位，相当于处以2，右移2位，除以2的平方，右移3位，处以2的3次方…..

/**

* 左移，右移

* 用于2个整数计算时，以下3个都需要先将整数转换成二进制

* 异或 ^相同为0，不同为1

* & 2个数相与，两个都为1的时候，才为1

* | 只要有1个为1，结果就为1，如果2个都为0，才为0

* @author Administrator

public class Test05 {

public static void main(String[] args) {

//3乘以2的5次方

System.out.println(3<<5);

//37处以8

System.out.println(37>>3);

//79处以32

System.out.println(79>>5);

//异或，首先2个数要先转换成2进制

System.out.println(17^23);//6

System.out.println(34^39);//5

//按位与 &

System.out.println(17&92);//16

//按位或 |

System.out.println(27|19); // 27

}

1.16. 三元运算符

条件表达式？值1：值2 如果条件表达式为真，那么整个表达式的值取的值1，否则取值2

public class TestSanmu {

public static void main(String[] args) {

int num1 = 10,num2=20,num3=30;

//int num = (5>3)?1:2;

//int num = (5<3)?1:2;

//int num = (((num1++)+3)>30?6+num2--:++num3+3);

// 34 , 11,20,31

int num = (++num1-num3--)==33?(++num2-num1--+num3++):(--num2+num2--+num3+++5);

//72,11,18,30

// (11-30)==33 ? (19+19+29+5)=72 num1=11 ,num2 = 18 num3 =30

System.out.println("num="+num+",num1="+num1+",num2="+num2+",num3="+num3);

}

1.17. 补充运算符优先级

结合性：运算的顺序，右--à左 ++，--，？：

1.18. 课堂练习

l 在控制台分别输入两个成绩85.1分和61.2，比较大小，输出较大的那个分数。

l 幸运抽奖。在控制台输入一个5位数字，如果前四位数字之和大于20，输出你中奖了，否则输出没中奖。

1.19. 作业

（1）02.变量、数据类型和运算符.doc

（2）分别输入两个数字，在控制台输出他们的和。

（3）分别输入三个数字，在控制台输出平均数。

（4）分别输入两个男生的身高和两个女生的身高，在控制台输出这两个男生的平均身高比两个女生的平均身高高出多少。

（5）输入一个6位的整数，如果第三位至第五位是666，在控制台输出你中奖了。

（6）分别输入两个不同的整数，使用三元运算符进行判断，在控制台输出其中较大的一个数字。

（7）分别输入两个6位的整数，分别取出这两个6位数的第4位的数字，在控制台输出这两个数字其中较大的一个数字。

（8）分别输入三个4位的整数，取出第一个整数的第2位数字，取出第二个整数的第3位数字，取出第三个整数的第4位数字，计算取出的这三个数字的平均值。

玉龙1989

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
复制链接

分享到 QQ

分享到新浪微博

扫一扫

专栏目录