一、数据类型
1、变量的命名
变量:存储数据的空间(装数据的容器)
通过变量名来操作变量里面的数据,变量命名规则:
1)变量名由字母、数字、下划线_、美元符号$组成
2)变量名不能以数字开头, 不建议使用美元符号开头
3)变量名不能使用Java关键字(Java中关键字大概有50个)
4)变量名采用小驼峰命名法
5)变量名要做到见名知意
6)Java是严格区分大小写
变量准备好之后,要准备数据,Java对数据进行了分类:
2、数据类型:
基本数据类型(8个)
数值型数据
整型数据:byte、short、int、long
浮点型数据:float、double
非数据型数据
字符char使用单引号''括起来,单引号''中只能写一个中文汉字或者一个英文字符
布尔类型boolean布尔类型的变量中只能存放两个数据true、false
引用数据类型(3个)
数组、类、接口
3、变量
概念:在程序运行中其值可以改变的量,变量是Java程序的一个程序的一个基本储存单元。
语法:[访问修饰符]变量类型 变量名 [=初始值]
(1)变量类型“可以从数据类型中选择”
(2)“变量名”是定义的名称变量,要遵循标识符命名规则
(3)中括号中的内容为初始值,可选项
package cn.bdqn.demo01;
public class Demo01 {
public static void main(String[] args) {
byte num1;
short num2;
int num3;
long num4;
float num5;
double num6;
char ch1;
boolean bool1;
//赋值:将数据存储到变量中
//变量名 = 数据;
num1 = 10;
num2 = 100;
num3 = 1000;
num4 = 100000000000L; //这里我们要注意long类型后面要加L(因为默认为int类型)
num5 = 95.25F; //这里float后面要加F(因为默认为double)
num6 = 100.99;
ch1 = 'f';
bool1 = true;
//操作数据:通过操作变量名就可以实现操作数据
System.out.println("num1");//num1 双引号里的内容原封不等输出
System.out.println(num1);//10 输出变量实际上输出的是变量里存储的数据
}
}
声明变量、变量赋值合并写
package cn.bdqn.demo01;
public class Demo02 {
public static void main(String[] args) {
//声明变量、变量赋值合并写
//数据类型 变量名 = 数据;
byte num1 = 10;
short num2 = 10;
int num3 = 100;
long num4 = 1000L;
float num5 = 12.99F;
double num6 =99.99;
char ch1 = '好';
boolean bool1 = false;
//通过变量名来操作变量里的数据
System.out.println(num1);//10
System.out.println(num2);//10
System.out.println(num3);//100
System.out.println(num4);//1000L
System.out.println(num5);//12.99
System.out.println(num6);//99.99
System.out.println(ch1);//好
System.out.println(bool1);//false
}
}
字符串类型的数据是一个类类型的数据,是引用类型数据
package cn.bdqn.demo01;
public class Demo03 {
public static void main(String[] args) {
// 字符串类型的数据是一个类类型的数据,是引用类型数据
//String 变量名 = "你要写的内容";
String str1;
str1 = "qwert";
System.out.println(str1);//qwert
String str2 = "asdfg";
System.out.println(str2);//asdfg
System.out.println("zxcvbnm");//zxcvbnm
System.out.println("qwert"+"-"+"asdfg");//qwert-asdfg
System.out.println("str1中存储的内容为:"+str1);//str1中存储的内容为:qwert
}
}
变量在赋值后可以重新进行赋值
package cn.bdqn.demo03;
public class Demo01 {
public static void main(String[] args) {
int num = 100;
System.out.println(num);//100
//变量在赋值后可以重新进行赋值
num = 200;
System.out.println(num);//200
}
}
5、常量
概念;在程序运行中不能被改变的量
常量名字母全部大小写
常量名多个单词之间使用下划线隔开
常量一般在定义时初始化
分类
整型常量、浮点型常量、布尔常量、字符常量、字符串常量、null常量、符号常量
package cn.bdqn.demo03;
public class Demo02 {
public static void main(String[] args) {
/*
* 常量:程序运行中,值不能改变的量称之为常量,常量使用final关键字进行修饰
* (1)常量名全部使用大写字母,多个单词之间使用下划线隔开
* (2)常量一般在声明的时候就进行赋值
*
* 语法格式:
* final 数据类型 常量名 = 数据;
*
*/
final byte STUDENT_SCORE = 98;
System.out.println(STUDENT_SCORE);
//STUDENT_SCORE = 99; //常量值不能进行重新赋值
final short STUDENT_NUMBER;
STUDENT_NUMBER = 1153;
System.out.println("学生的学号是:"+STUDENT_NUMBER);
final String GENDER = "男";
System.out.println("该学生的性别是:"+GENDER);
}
}
6、数据类型转换
算术运算时
不同类型的操作数,首先自动转换为表达式中做高级别的数据类型,然后进行运算,运算的结果是最高级别的数据类型,简称低级别自动转换为高级别
赋值运算时
自动类型转换:将低级别的类型赋值给高级别类型时将进行自动类型转换
强制类型转换
概念:将高级别的类型赋值给低级别类型是,必须进行强制类型转换
注意:进行强制类型转换时,可能会丢失数据
package cn.bdqn.demo01;
public class Demo01 {
public static void main(String[] args) {
//自动类型转换:小范围的数据存储到大范围的变量中
byte num1 = 100;
int num2 =num1;
System.out.println(num2);//100
//强制类型转换:大范围的数据存储到小范围的变量中。注意:有可能存储的了。也有可能大范围的数据超过了小范围数据的范围,这个时候数据就会出现精度丢失
int num3 =129;
byte num4 =(byte)num3;
System.out.println(num4);//120
}
}
7、Scanner类的使用
(1)导入Scanner类
import java.util.*;
(2)创建Scanner对象
Scanner sc = new Scanner(System.in);
(3)获得键盘输入的数据
String next():获得一个字符串
int nextInt():获得一个整型数值
double nextdouble():获得一个双精度类型数值
boolean hasNext():判断是否有输入数据,如果有输入数据,则返回true;否则,返回false
package cn.bdqn.demo04;
//要想在当前这个类中使用JDK中java文件夹里的util文件夹内的Scanner类,就必须先将这个类“导入”到当前这个类中
//导包可以手动的在package和public class之间编写,还可以在创建Scanner类对象之后,通过鼠标点击实现导包,还可以在创建Scanner类对象后通过导包快捷键Ctrl+Shift+O导入
//第一步:导包
import java.util.Scanner;
public class ScannerDemo01 {
public static void main(String[] args) {
//第二步:创建Scanner类对象(这个是固定写法,先学会写就可以了)
Scanner input = new Scanner(System.in);
//获取数据
/*
* nextInt():获取int类型的数据
* next():获取String类型的数据
* nextDouble():获取double类型的数据
*/
System.out.println("请输入一个整数:");
int num =input.nextInt();
System.out.println("您输入的整数是:"+num);
System.out.println("请输入您的姓名:");
String name =input.next();
System.out.println("您的姓名是:"+name);
System.out.println("请输入您的分数:");
double score=input.nextDouble();
System.out.println("您的分数是:"+score);
input.close();
}
}
二、运算符
1、赋值运算符
=:用于给变量指定变量值
复合赋值运算符
+=、-=、*=、/=、%=
2、算术运算符
+、-、*、/、%、++、--
package cn.bdqn.demo03;
public class Demo01 {
public static void main(String[] args) {
/*
* 算术运算符:
* 基本算术运算符:+ - * / %(取模运算符符 或 取余运算符) ++(自增运算符) --(自减运算符)
* 复合算术运算符:+= -= *= /= %=
*/
int num1 = 20;
int num2 = 3;
int result1 = num1 + num2;
System.out.println("num1+num2="+result1);//num1+num2=23
int result2 = num1 - num2;
System.out.println("num1-num2="+result2);//num1-num2=17
int result3 = num1 * num2;
System.out.println("num1*num2="+result3);//num1*num2=60
// /是除法运算符,取商
int result4 = num1 / num2;
System.out.println("num1/num2="+result4);//num1/num2=6
// %是取模运算符符或者取余运算符,取余数
int result5 = num1 % num2;
System.out.println("num1%num2="+result5);//num1%num2=2
// ++ 自增运算符,每次对数据进行+1操作
int number1 = 100;
System.out.println("number1="+number1);//number1=100
//number1++;
++number1;
System.out.println("number1="+number1);//number1=101
// -- 自减运算符,每次对数据进行-1操作
int number2 = 1000;
System.out.println("number2="+number2);//number1=1000
//number2--;
--number2;
System.out.println("number2="+number2);//number2=999;
}
}
3、关系运算符(比较运算符)
种类
==、!=、>、<、>=、<=
注意
“=”为赋值运算符,“==”为等于运算符
“>”、“<”、“>=”、“<=”只支持数值类型的比较
“==”、“!=”支持所有数据类型的比较,包括数值类型、布尔类型、引用类型
关系表达式运算的结果为布尔值
“>”、“<”、“>=”、"<=“优先级别高于”==“、”!=“
4、逻辑运算符
种类
&、|、^、!、&&、||
注意
操作数类型只能是布尔类型,操作结果也是布尔类型
优先级别:“!”>“&”>“^”>“|”>“&&”>“||”
“&&”和“&”的区别(当“&&”的左侧为false时,将不会计算其右侧的表达式,即左false则false;无论任何情况,“&”两侧的表达式都会参与计算)
“||”和“|”的区别(当“||”的左侧为true时,将不会计算其右侧的表达式,即左true则true;无论任何情况,“|”两侧的表达式都会参与计算)
package cn.bdqn.demo01;
public class Demo01 {
public static void main(String[] args) {
// true && true-->true
boolean result1 = true && true;
System.out.println("true&&true:" + result1);// true&&true:true
// true && false-->true
boolean result2 = true && false;
System.out.println("true&&false:" + result2);// true&&false:false
// false && true-->true
boolean result3 = false && true;
System.out.println("false&&true:" + result3);// false&&true:false
// fasle && fasle-->false
boolean result4 = false && false;
System.out.println("false&&false:" + result4);// false&&false:false
/*
* &&运算规律:只有当&&左右两边的表达式同时为true,&&运算结果为true
* &运算规律:只有当&左右两边的表达式同时为true,&运算结果为true
*/
// true & true-->true
boolean result5 = true & true;
System.out.println("true&true:" + result5);// true&true:true
// true & false-->true
boolean result6 = true & false;
System.out.println("true&false:" + result6);// true&false:false
// false & true-->true
boolean result7 = false & true;
System.out.println("false&true:" + result7);// false&true:false
// fasle & fasle-->true
boolean result8 = false & false;
System.out.println("false&false:" + result8);// false&false:false
}
}
package cn.bdqn.demo01;
public class Demo02 {
public static void main(String[] args) {
// true || true-->true
boolean result1 = true || true;
System.out.println("true||true:" + result1);// true||true:true
// true || false-->true
boolean result2 = true || false;
System.out.println("true||false:" + result2);// true||false:true
// false || true-->true
boolean result3 = false || true;
System.out.println("false||true:" + result3);// false||true:true
// fasle || fasle-->false
boolean result4 = false || false;
System.out.println("false||false:" + result4);// false||false:false
/*
* ||运算规律:只要||左右两边有一个为true,||运算结果为true
* |运算规律:只要|左右两边有一个为true,|运算结果为true
*/
// true | true-->true
boolean result5 = true | true;
System.out.println("true|true:" + result5);// true|true:true
// true | false-->true
boolean result6 = true | false;
System.out.println("true|false:" + result6);// true|false:true
// false | true-->true
boolean result7 = false | true;
System.out.println("false|true:" + result7);// false|true:true
// fasle | fasle-->true
boolean result8 = false | false;
System.out.println("false|false:" + result8);// false|false:false
}
}
package cn.bdqn.demo02;
public class Demo08 {
public static void main(String[] args) {
int x = 8;
int y = 9;
System.out.println((++x != y) | (++x == y));// false
System.out.println(x);// 10
/*
* &&和&的区别:
* &&具有短路功能,当&&左边表达式为false的时候,直接判断整个&&运算结果为false,&&右边不再进行计算
* &不具有短路功能,不管&左边表达式的结果为true还是false,&右边表达式都要进行计算
*
* ||和|的区别:
* ||具有短路功能,当||左边表达式为true的时候,直接判断整个||运算结果为true,||右边不再进行计算
* |不具有短路功能,不管|左边表达式的结果为true还是false,|右边表达式都要进行计算
*
*
*
*/
}
}
5、位运算符
种类
“&:按位与”
”|:按位或“
“^:按位异或”
”~:按位非/取反“
“<<:左移”
“>>:右移”
“>>>:无符号右移”
注意
一个整数每向左移动1位,其值扩大2倍,前提是移出数不包含有效数字
a=a*4和a=a<<2的作用是相同的,但是使用位运算符执行效率更高
一个整数每向右移动一位,其值缩小1/2,前提是溢出位中不包含有效数字
位运算符对操作数以二进制为单位进行运算
位运算符的操作数是整型数,包括int、short、long、byte和char
位运算符的运算结果也是整型数,包括int、long
如果操作数是char、byte、short,位运算前其值会自动晋升为int,运算结果也为int
6、条件运算符(三目运算符、三元运算符)
语法
条件?表达式1:表达式2
运算规则
首先对条件进行判断,如果结果为true,则返回表达式1的值
如果结果为false,返回表达式2的值
package cn.bdqn.demo03;
public class Demo01 {
public static void main(String[] args) {
/*
* 条件运算符(三目运算符/三元运算符):
* 语法结构:
* 条件?表达式1:表达式2;
* 执行规律:
* 条件为true,执行表达式1
* 条件为false,执行表达式2
*/
// 需求:获取2个数里面的最大值
int num1 = 1000;
int num2 = 200;
int max = num1 > num2 ? num1 : num2;
System.out.println("最大值:"+max);
int min =num1>num2?num2:num1;
System.out.println("最小值:"+min);
}
}
嵌套条件运算符
package cn.bdqn.demo03;
public class Demo03 {
public static void main(String[] args) {
/*
* 嵌套条件运算符:
* 语法规则:
* 条件1?(条件2?表达式1:表达式2):(条件3?表达式3:表达式4);
* 执行规律:
* 条件1为true,继续判断条件2,条件2为true,执行表达式1,条件2为false,执行表达式2
* 条件1为false,继续判断条件3,条件3为true,执行表达式3,条件3为false,执行表达式4
*
*/
//获取3个数中的最大值或者最小值
int a = 10;
int b = 30;
int c = 20;
int max =a>b?(a>c?a:c):(b>c?b:c);
System.out.println("最大值:"+max);
int min = a>b?(b>c?c:b):(a>c?c:a);
System.out.println("最小值:"+min);
}
}
7、运算符的优先级和结合性
(1)优先级
优先级越高,在表达式中运算顺序越靠前
(2)结合性
结合性可以理解为运算的方向
大多数运算符的结合性都是从左向右,即从左向右依次进行运算
(3)注意
优先级最低的是赋值运算符,其次是条件运算符
单目运算符包括“!”、“~”、“++”、“--”,优先级别高
可以通过“()”控制表达式的运算顺序,“()”优先级最高
总体而言,优先顺序为算术运算符>关系运算符>逻辑运算符
结合性从右向左的只有赋值运算符、三目运算符和单目运算符(一个操作数)