Java变量、数据类型和运算符 2
1. 变量
计算机处理数据,变量被用来存储处理的数据,之所以叫做变量因为你可以改变存储的值。更确切的说,一个变量指向着一块存储特定类型值的地址,换句话说,一个变量有名称、类型和值。一个变量有一个名称,例如radius、area、age和height,每个变量的名称都是唯一的,这边可以方便我们设置和获取变量的值。
我们简单的拿生活中的旅馆来举例
旅馆中的房间 变量
房间名称 变量名
房间类型 变量类型
入住的客人 变量的值
通过变量名可以简单快速的找到他存储的数据。将数据指定给变量,就是将数据存储到以别名为变量名的那个房间;调用变量,就是将那个房间中的数据取出来使用。可见,变量是存储数据的一个基本单元,不同的变量相互独立。
一个变量有一种类型,下面是Java类型的列子:
int: 表示整数例如123和-456
double: 表示浮点数例如3.1416、-55.66、1.2e3和-4.5E-6
String: 表示文本例如"Hello"、"Good Morning!",文本通常嵌入在双引号里面
char: 表示单个字符例如'a','8',单个字符通常嵌入在单引号里面。
变量存储特定类型的值,编程中要特别注意变量类型,举例:一个int变量存储整数123,但是不能存储浮点数12.34,同样也不能存储文本"Hello"。
早期的编程语言中引入了类型的概念来解释二进制01数据,类型定义了数据的结构、大小、范围以及针对该类型的一系列操作。
2.名称
标识由大小写字母、数字、下划线和$的任意长度的字符序列组成。
空白 (空格、制表符、换行符)和其他特殊字符 (如+ - * / @ &, 等)是不允许的,错误的命名方式:max value和max-value。
标识符不能以数字(0-9)开头必须以字母(a-z, A-Z)、下划线(_)和$开头,系统保留以$开头的标识。
标识符不能使用关键字和预留字段 (例如:class,int,double,if,else,for,true,false,null)。
标识符是区分大小写的,rose、Rose和ROSE是3个不同的变量。
Java中八种常用数据类型:
int,double,short,float,boolean,byte,long,char
字节:
数字,英文(无论大小写),英文标点都占用一个字节
汉子,中文的标点符号占用两个字节
内存:
计算机使用内存来存储计算时所需要的数据
创建变量的两种方式:
1.声明-->赋值-->取值
//声明变量
int money;
//存钱
//=:赋值运算符(将右边的值赋值给左边)
//赋值变量
money=1000;
//+:用于连接
//调用变量
System.out.println("存储"+":"+money);
2.声明+赋值-->取值
double price=99.99;
System.out.println(price);
常量:
//常量final:一但赋值不可改变
final int sum;
sum=3;
3.运算符
1.赋值运算符:
=:代表赋值运算符:将右边的值赋值给左边
2.算数运算符:
+:加法 a+b
-:减法 a-b
*:乘法 a*b
/:除法 a/b
%:取余 a%b
3.关系运算符:
>:大于 10>13 结果为false
<:小于 10<13 结果为true
>=:大于等于
<=:小于等于
==:等于
!=:不等于0
扫描仪:
Scanner input=new Scanner(
System.in);
导包:java.lang.util
Boolean类型:
取值:
false :假
true:真
运算符的优先级:算数运算符>关系运算符>逻辑运算符,即在一个表达式中,算数运算符的优先等级最高,关系运算符次之,然后是逻辑运算符。逻辑运算符将在下一章进行学习。如果在一个表达式中包含赋值运算符,则它的优先级最低。
计算机处理数据,变量被用来存储处理的数据,之所以叫做变量因为你可以改变存储的值。更确切的说,一个变量指向着一块存储特定类型值的地址,换句话说,一个变量有名称、类型和值。一个变量有一个名称,例如radius、area、age和height,每个变量的名称都是唯一的,这边可以方便我们设置和获取变量的值。
我们简单的拿生活中的旅馆来举例
旅馆中的房间 变量
房间名称 变量名
房间类型 变量类型
入住的客人 变量的值
通过变量名可以简单快速的找到他存储的数据。将数据指定给变量,就是将数据存储到以别名为变量名的那个房间;调用变量,就是将那个房间中的数据取出来使用。可见,变量是存储数据的一个基本单元,不同的变量相互独立。
一个变量有一种类型,下面是Java类型的列子:
int: 表示整数例如123和-456
double: 表示浮点数例如3.1416、-55.66、1.2e3和-4.5E-6
String: 表示文本例如"Hello"、"Good Morning!",文本通常嵌入在双引号里面
char: 表示单个字符例如'a','8',单个字符通常嵌入在单引号里面。
变量存储特定类型的值,编程中要特别注意变量类型,举例:一个int变量存储整数123,但是不能存储浮点数12.34,同样也不能存储文本"Hello"。
早期的编程语言中引入了类型的概念来解释二进制01数据,类型定义了数据的结构、大小、范围以及针对该类型的一系列操作。
2.名称
标识由大小写字母、数字、下划线和$的任意长度的字符序列组成。
空白 (空格、制表符、换行符)和其他特殊字符 (如+ - * / @ &, 等)是不允许的,错误的命名方式:max value和max-value。
标识符不能以数字(0-9)开头必须以字母(a-z, A-Z)、下划线(_)和$开头,系统保留以$开头的标识。
标识符不能使用关键字和预留字段 (例如:class,int,double,if,else,for,true,false,null)。
标识符是区分大小写的,rose、Rose和ROSE是3个不同的变量。
Java中八种常用数据类型:
int,double,short,float,boolean,byte,long,char
字节:
数字,英文(无论大小写),英文标点都占用一个字节
汉子,中文的标点符号占用两个字节
内存:
计算机使用内存来存储计算时所需要的数据
创建变量的两种方式:
1.声明-->赋值-->取值
//声明变量
int money;
//存钱
//=:赋值运算符(将右边的值赋值给左边)
//赋值变量
money=1000;
//+:用于连接
//调用变量
System.out.println("存储"+":"+money);
2.声明+赋值-->取值
double price=99.99;
System.out.println(price);
常量:
//常量final:一但赋值不可改变
final int sum;
sum=3;
3.运算符
1.赋值运算符:
=:代表赋值运算符:将右边的值赋值给左边
2.算数运算符:
+:加法 a+b
-:减法 a-b
*:乘法 a*b
/:除法 a/b
%:取余 a%b
3.关系运算符:
>:大于 10>13 结果为false
<:小于 10<13 结果为true
>=:大于等于
<=:小于等于
==:等于
!=:不等于0
扫描仪:
Scanner input=new Scanner(
导包:java.lang.util
Boolean类型:
取值:
false :假
true:真
运算符的优先级:算数运算符>关系运算符>逻辑运算符,即在一个表达式中,算数运算符的优先等级最高,关系运算符次之,然后是逻辑运算符。逻辑运算符将在下一章进行学习。如果在一个表达式中包含赋值运算符,则它的优先级最低。
1. 变量
计算机处理数据,变量被用来存储处理的数据,之所以叫做变量因为你可以改变存储的值。更确切的说,一个变量指向着一块存储特定类型值的地址,换句话说,一个变量有名称、类型和值。一个变量有一个名称,例如radius、area、age和height,每个变量的名称都是唯一的,这边可以方便我们设置和获取变量的值。
我们简单的拿生活中的旅馆来举例
旅馆中的房间 变量
房间名称 变量名
房间类型 变量类型
入住的客人 变量的值
通过变量名可以简单快速的找到他存储的数据。将数据指定给变量,就是将数据存储到以别名为变量名的那个房间;调用变量,就是将那个房间中的数据取出来使用。可见,变量是存储数据的一个基本单元,不同的变量相互独立。
一个变量有一种类型,下面是Java类型的列子:
int: 表示整数例如123和-456
double: 表示浮点数例如3.1416、-55.66、1.2e3和-4.5E-6
String: 表示文本例如"Hello"、"Good Morning!",文本通常嵌入在双引号里面
char: 表示单个字符例如'a','8',单个字符通常嵌入在单引号里面。
变量存储特定类型的值,编程中要特别注意变量类型,举例:一个int变量存储整数123,但是不能存储浮点数12.34,同样也不能存储文本"Hello"。
早期的编程语言中引入了类型的概念来解释二进制01数据,类型定义了数据的结构、大小、范围以及针对该类型的一系列操作。
2.名称
标识由大小写字母、数字、下划线和$的任意长度的字符序列组成。
空白 (空格、制表符、换行符)和其他特殊字符 (如+ - * / @ &, 等)是不允许的,错误的命名方式:max value和max-value。
标识符不能以数字(0-9)开头必须以字母(a-z, A-Z)、下划线(_)和$开头,系统保留以$开头的标识。
标识符不能使用关键字和预留字段 (例如:class,int,double,if,else,for,true,false,null)。
标识符是区分大小写的,rose、Rose和ROSE是3个不同的变量。
Java中八种常用数据类型:
int,double,short,float,boolean,byte,long,char
字节:
数字,英文(无论大小写),英文标点都占用一个字节
汉子,中文的标点符号占用两个字节
内存:
计算机使用内存来存储计算时所需要的数据
创建变量的两种方式:
1.声明-->赋值-->取值
//声明变量
int money;
//存钱
//=:赋值运算符(将右边的值赋值给左边)
//赋值变量
money=1000;
//+:用于连接
//调用变量
System.out.println("存储"+":"+money);
2.声明+赋值-->取值
double price=99.99;
System.out.println(price);
常量:
//常量final:一但赋值不可改变
final int sum;
sum=3;
3.运算符
1.赋值运算符:
=:代表赋值运算符:将右边的值赋值给左边
2.算数运算符:
+:加法 a+b
-:减法 a-b
*:乘法 a*b
/:除法 a/b
%:取余 a%b
3.关系运算符:
>:大于 10>13 结果为false
<:小于 10<13 结果为true
>=:大于等于
<=:小于等于
==:等于
!=:不等于0
扫描仪:
Scanner input=new Scanner(
System.in);
导包:java.lang.util
Boolean类型:
取值:
false :假
true:真
运算符的优先级:算数运算符>关系运算符>逻辑运算符,即在一个表达式中,算数运算符的优先等级最高,关系运算符次之,然后是逻辑运算符。逻辑运算符将在下一章进行学习。如果在一个表达式中包含赋值运算符,则它的优先级最低。
计算机处理数据,变量被用来存储处理的数据,之所以叫做变量因为你可以改变存储的值。更确切的说,一个变量指向着一块存储特定类型值的地址,换句话说,一个变量有名称、类型和值。一个变量有一个名称,例如radius、area、age和height,每个变量的名称都是唯一的,这边可以方便我们设置和获取变量的值。
我们简单的拿生活中的旅馆来举例
旅馆中的房间 变量
房间名称 变量名
房间类型 变量类型
入住的客人 变量的值
通过变量名可以简单快速的找到他存储的数据。将数据指定给变量,就是将数据存储到以别名为变量名的那个房间;调用变量,就是将那个房间中的数据取出来使用。可见,变量是存储数据的一个基本单元,不同的变量相互独立。
一个变量有一种类型,下面是Java类型的列子:
int: 表示整数例如123和-456
double: 表示浮点数例如3.1416、-55.66、1.2e3和-4.5E-6
String: 表示文本例如"Hello"、"Good Morning!",文本通常嵌入在双引号里面
char: 表示单个字符例如'a','8',单个字符通常嵌入在单引号里面。
变量存储特定类型的值,编程中要特别注意变量类型,举例:一个int变量存储整数123,但是不能存储浮点数12.34,同样也不能存储文本"Hello"。
早期的编程语言中引入了类型的概念来解释二进制01数据,类型定义了数据的结构、大小、范围以及针对该类型的一系列操作。
2.名称
标识由大小写字母、数字、下划线和$的任意长度的字符序列组成。
空白 (空格、制表符、换行符)和其他特殊字符 (如+ - * / @ &, 等)是不允许的,错误的命名方式:max value和max-value。
标识符不能以数字(0-9)开头必须以字母(a-z, A-Z)、下划线(_)和$开头,系统保留以$开头的标识。
标识符不能使用关键字和预留字段 (例如:class,int,double,if,else,for,true,false,null)。
标识符是区分大小写的,rose、Rose和ROSE是3个不同的变量。
Java中八种常用数据类型:
int,double,short,float,boolean,byte,long,char
字节:
数字,英文(无论大小写),英文标点都占用一个字节
汉子,中文的标点符号占用两个字节
内存:
计算机使用内存来存储计算时所需要的数据
创建变量的两种方式:
1.声明-->赋值-->取值
//声明变量
int money;
//存钱
//=:赋值运算符(将右边的值赋值给左边)
//赋值变量
money=1000;
//+:用于连接
//调用变量
System.out.println("存储"+":"+money);
2.声明+赋值-->取值
double price=99.99;
System.out.println(price);
常量:
//常量final:一但赋值不可改变
final int sum;
sum=3;
3.运算符
1.赋值运算符:
=:代表赋值运算符:将右边的值赋值给左边
2.算数运算符:
+:加法 a+b
-:减法 a-b
*:乘法 a*b
/:除法 a/b
%:取余 a%b
3.关系运算符:
>:大于 10>13 结果为false
<:小于 10<13 结果为true
>=:大于等于
<=:小于等于
==:等于
!=:不等于0
扫描仪:
Scanner input=new Scanner(
导包:java.lang.util
Boolean类型:
取值:
false :假
true:真
运算符的优先级:算数运算符>关系运算符>逻辑运算符,即在一个表达式中,算数运算符的优先等级最高,关系运算符次之,然后是逻辑运算符。逻辑运算符将在下一章进行学习。如果在一个表达式中包含赋值运算符,则它的优先级最低。
1. 变量
计算机处理数据,变量被用来存储处理的数据,之所以叫做变量因为你可以改变存储的值。更确切的说,一个变量指向着一块存储特定类型值的地址,换句话说,一个变量有名称、类型和值。一个变量有一个名称,例如radius、area、age和height,每个变量的名称都是唯一的,这边可以方便我们设置和获取变量的值。
我们简单的拿生活中的旅馆来举例
旅馆中的房间 变量
房间名称 变量名
房间类型 变量类型
入住的客人 变量的值
通过变量名可以简单快速的找到他存储的数据。将数据指定给变量,就是将数据存储到以别名为变量名的那个房间;调用变量,就是将那个房间中的数据取出来使用。可见,变量是存储数据的一个基本单元,不同的变量相互独立。
一个变量有一种类型,下面是Java类型的列子:
int: 表示整数例如123和-456
double: 表示浮点数例如3.1416、-55.66、1.2e3和-4.5E-6
String: 表示文本例如"Hello"、"Good Morning!",文本通常嵌入在双引号里面
char: 表示单个字符例如'a','8',单个字符通常嵌入在单引号里面。
变量存储特定类型的值,编程中要特别注意变量类型,举例:一个int变量存储整数123,但是不能存储浮点数12.34,同样也不能存储文本"Hello"。
早期的编程语言中引入了类型的概念来解释二进制01数据,类型定义了数据的结构、大小、范围以及针对该类型的一系列操作。
2.名称
标识由大小写字母、数字、下划线和$的任意长度的字符序列组成。
空白 (空格、制表符、换行符)和其他特殊字符 (如+ - * / @ &, 等)是不允许的,错误的命名方式:max value和max-value。
标识符不能以数字(0-9)开头必须以字母(a-z, A-Z)、下划线(_)和$开头,系统保留以$开头的标识。
标识符不能使用关键字和预留字段 (例如:class,int,double,if,else,for,true,false,null)。
标识符是区分大小写的,rose、Rose和ROSE是3个不同的变量。
Java中八种常用数据类型:
int,double,short,float,boolean,byte,long,char
字节:
数字,英文(无论大小写),英文标点都占用一个字节
汉子,中文的标点符号占用两个字节
内存:
计算机使用内存来存储计算时所需要的数据
创建变量的两种方式:
1.声明-->赋值-->取值
//声明变量
int money;
//存钱
//=:赋值运算符(将右边的值赋值给左边)
//赋值变量
money=1000;
//+:用于连接
//调用变量
System.out.println("存储"+":"+money);
2.声明+赋值-->取值
double price=99.99;
System.out.println(price);
常量:
//常量final:一但赋值不可改变
final int sum;
sum=3;
3.运算符
1.赋值运算符:
=:代表赋值运算符:将右边的值赋值给左边
2.算数运算符:
+:加法 a+b
-:减法 a-b
*:乘法 a*b
/:除法 a/b
%:取余 a%b
3.关系运算符:
>:大于 10>13 结果为false
<:小于 10<13 结果为true
>=:大于等于
<=:小于等于
==:等于
!=:不等于0
扫描仪:
Scanner input=new Scanner(
System.in);
导包:java.lang.util
Boolean类型:
取值:
false :假
true:真
运算符的优先级:算数运算符>关系运算符>逻辑运算符,即在一个表达式中,算数运算符的优先等级最高,关系运算符次之,然后是逻辑运算符。逻辑运算符将在下一章进行学习。如果在一个表达式中包含赋值运算符,则它的优先级最低。
计算机处理数据,变量被用来存储处理的数据,之所以叫做变量因为你可以改变存储的值。更确切的说,一个变量指向着一块存储特定类型值的地址,换句话说,一个变量有名称、类型和值。一个变量有一个名称,例如radius、area、age和height,每个变量的名称都是唯一的,这边可以方便我们设置和获取变量的值。
我们简单的拿生活中的旅馆来举例
旅馆中的房间 变量
房间名称 变量名
房间类型 变量类型
入住的客人 变量的值
通过变量名可以简单快速的找到他存储的数据。将数据指定给变量,就是将数据存储到以别名为变量名的那个房间;调用变量,就是将那个房间中的数据取出来使用。可见,变量是存储数据的一个基本单元,不同的变量相互独立。
一个变量有一种类型,下面是Java类型的列子:
int: 表示整数例如123和-456
double: 表示浮点数例如3.1416、-55.66、1.2e3和-4.5E-6
String: 表示文本例如"Hello"、"Good Morning!",文本通常嵌入在双引号里面
char: 表示单个字符例如'a','8',单个字符通常嵌入在单引号里面。
变量存储特定类型的值,编程中要特别注意变量类型,举例:一个int变量存储整数123,但是不能存储浮点数12.34,同样也不能存储文本"Hello"。
早期的编程语言中引入了类型的概念来解释二进制01数据,类型定义了数据的结构、大小、范围以及针对该类型的一系列操作。
2.名称
标识由大小写字母、数字、下划线和$的任意长度的字符序列组成。
空白 (空格、制表符、换行符)和其他特殊字符 (如+ - * / @ &, 等)是不允许的,错误的命名方式:max value和max-value。
标识符不能以数字(0-9)开头必须以字母(a-z, A-Z)、下划线(_)和$开头,系统保留以$开头的标识。
标识符不能使用关键字和预留字段 (例如:class,int,double,if,else,for,true,false,null)。
标识符是区分大小写的,rose、Rose和ROSE是3个不同的变量。
Java中八种常用数据类型:
int,double,short,float,boolean,byte,long,char
字节:
数字,英文(无论大小写),英文标点都占用一个字节
汉子,中文的标点符号占用两个字节
内存:
计算机使用内存来存储计算时所需要的数据
创建变量的两种方式:
1.声明-->赋值-->取值
//声明变量
int money;
//存钱
//=:赋值运算符(将右边的值赋值给左边)
//赋值变量
money=1000;
//+:用于连接
//调用变量
System.out.println("存储"+":"+money);
2.声明+赋值-->取值
double price=99.99;
System.out.println(price);
常量:
//常量final:一但赋值不可改变
final int sum;
sum=3;
3.运算符
1.赋值运算符:
=:代表赋值运算符:将右边的值赋值给左边
2.算数运算符:
+:加法 a+b
-:减法 a-b
*:乘法 a*b
/:除法 a/b
%:取余 a%b
3.关系运算符:
>:大于 10>13 结果为false
<:小于 10<13 结果为true
>=:大于等于
<=:小于等于
==:等于
!=:不等于0
扫描仪:
Scanner input=new Scanner(
导包:java.lang.util
Boolean类型:
取值:
false :假
true:真
运算符的优先级:算数运算符>关系运算符>逻辑运算符,即在一个表达式中,算数运算符的优先等级最高,关系运算符次之,然后是逻辑运算符。逻辑运算符将在下一章进行学习。如果在一个表达式中包含赋值运算符,则它的优先级最低。
1. 变量
计算机处理数据,变量被用来存储处理的数据,之所以叫做变量因为你可以改变存储的值。更确切的说,一个变量指向着一块存储特定类型值的地址,换句话说,一个变量有名称、类型和值。一个变量有一个名称,例如radius、area、age和height,每个变量的名称都是唯一的,这边可以方便我们设置和获取变量的值。
我们简单的拿生活中的旅馆来举例
旅馆中的房间 变量
房间名称 变量名
房间类型 变量类型
入住的客人 变量的值
通过变量名可以简单快速的找到他存储的数据。将数据指定给变量,就是将数据存储到以别名为变量名的那个房间;调用变量,就是将那个房间中的数据取出来使用。可见,变量是存储数据的一个基本单元,不同的变量相互独立。
一个变量有一种类型,下面是Java类型的列子:
int: 表示整数例如123和-456
double: 表示浮点数例如3.1416、-55.66、1.2e3和-4.5E-6
String: 表示文本例如"Hello"、"Good Morning!",文本通常嵌入在双引号里面
char: 表示单个字符例如'a','8',单个字符通常嵌入在单引号里面。
变量存储特定类型的值,编程中要特别注意变量类型,举例:一个int变量存储整数123,但是不能存储浮点数12.34,同样也不能存储文本"Hello"。
早期的编程语言中引入了类型的概念来解释二进制01数据,类型定义了数据的结构、大小、范围以及针对该类型的一系列操作。
2.名称
标识由大小写字母、数字、下划线和$的任意长度的字符序列组成。
空白 (空格、制表符、换行符)和其他特殊字符 (如+ - * / @ &, 等)是不允许的,错误的命名方式:max value和max-value。
标识符不能以数字(0-9)开头必须以字母(a-z, A-Z)、下划线(_)和$开头,系统保留以$开头的标识。
标识符不能使用关键字和预留字段 (例如:class,int,double,if,else,for,true,false,null)。
标识符是区分大小写的,rose、Rose和ROSE是3个不同的变量。
Java中八种常用数据类型:
int,double,short,float,boolean,byte,long,char
字节:
数字,英文(无论大小写),英文标点都占用一个字节
汉子,中文的标点符号占用两个字节
内存:
计算机使用内存来存储计算时所需要的数据
创建变量的两种方式:
1.声明-->赋值-->取值
//声明变量
int money;
//存钱
//=:赋值运算符(将右边的值赋值给左边)
//赋值变量
money=1000;
//+:用于连接
//调用变量
System.out.println("存储"+":"+money);
2.声明+赋值-->取值
double price=99.99;
System.out.println(price);
常量:
//常量final:一但赋值不可改变
final int sum;
sum=3;
3.运算符
1.赋值运算符:
=:代表赋值运算符:将右边的值赋值给左边
2.算数运算符:
+:加法 a+b
-:减法 a-b
*:乘法 a*b
/:除法 a/b
%:取余 a%b
3.关系运算符:
>:大于 10>13 结果为false
<:小于 10<13 结果为true
>=:大于等于
<=:小于等于
==:等于
!=:不等于0
扫描仪:
Scanner input=new Scanner(
System.in);
导包:java.lang.util
Boolean类型:
取值:
false :假
true:真
运算符的优先级:算数运算符>关系运算符>逻辑运算符,即在一个表达式中,算数运算符的优先等级最高,关系运算符次之,然后是逻辑运算符。逻辑运算符将在下一章进行学习。如果在一个表达式中包含赋值运算符,则它的优先级最低。
计算机处理数据,变量被用来存储处理的数据,之所以叫做变量因为你可以改变存储的值。更确切的说,一个变量指向着一块存储特定类型值的地址,换句话说,一个变量有名称、类型和值。一个变量有一个名称,例如radius、area、age和height,每个变量的名称都是唯一的,这边可以方便我们设置和获取变量的值。
我们简单的拿生活中的旅馆来举例
旅馆中的房间 变量
房间名称 变量名
房间类型 变量类型
入住的客人 变量的值
通过变量名可以简单快速的找到他存储的数据。将数据指定给变量,就是将数据存储到以别名为变量名的那个房间;调用变量,就是将那个房间中的数据取出来使用。可见,变量是存储数据的一个基本单元,不同的变量相互独立。
一个变量有一种类型,下面是Java类型的列子:
int: 表示整数例如123和-456
double: 表示浮点数例如3.1416、-55.66、1.2e3和-4.5E-6
String: 表示文本例如"Hello"、"Good Morning!",文本通常嵌入在双引号里面
char: 表示单个字符例如'a','8',单个字符通常嵌入在单引号里面。
变量存储特定类型的值,编程中要特别注意变量类型,举例:一个int变量存储整数123,但是不能存储浮点数12.34,同样也不能存储文本"Hello"。
早期的编程语言中引入了类型的概念来解释二进制01数据,类型定义了数据的结构、大小、范围以及针对该类型的一系列操作。
2.名称
标识由大小写字母、数字、下划线和$的任意长度的字符序列组成。
空白 (空格、制表符、换行符)和其他特殊字符 (如+ - * / @ &, 等)是不允许的,错误的命名方式:max value和max-value。
标识符不能以数字(0-9)开头必须以字母(a-z, A-Z)、下划线(_)和$开头,系统保留以$开头的标识。
标识符不能使用关键字和预留字段 (例如:class,int,double,if,else,for,true,false,null)。
标识符是区分大小写的,rose、Rose和ROSE是3个不同的变量。
Java中八种常用数据类型:
int,double,short,float,boolean,byte,long,char
字节:
数字,英文(无论大小写),英文标点都占用一个字节
汉子,中文的标点符号占用两个字节
内存:
计算机使用内存来存储计算时所需要的数据
创建变量的两种方式:
1.声明-->赋值-->取值
//声明变量
int money;
//存钱
//=:赋值运算符(将右边的值赋值给左边)
//赋值变量
money=1000;
//+:用于连接
//调用变量
System.out.println("存储"+":"+money);
2.声明+赋值-->取值
double price=99.99;
System.out.println(price);
常量:
//常量final:一但赋值不可改变
final int sum;
sum=3;
3.运算符
1.赋值运算符:
=:代表赋值运算符:将右边的值赋值给左边
2.算数运算符:
+:加法 a+b
-:减法 a-b
*:乘法 a*b
/:除法 a/b
%:取余 a%b
3.关系运算符:
>:大于 10>13 结果为false
<:小于 10<13 结果为true
>=:大于等于
<=:小于等于
==:等于
!=:不等于0
扫描仪:
Scanner input=new Scanner(
导包:java.lang.util
Boolean类型:
取值:
false :假
true:真
运算符的优先级:算数运算符>关系运算符>逻辑运算符,即在一个表达式中,算数运算符的优先等级最高,关系运算符次之,然后是逻辑运算符。逻辑运算符将在下一章进行学习。如果在一个表达式中包含赋值运算符,则它的优先级最低。
1. 变量
计算机处理数据,变量被用来存储处理的数据,之所以叫做变量因为你可以改变存储的值。更确切的说,一个变量指向着一块存储特定类型值的地址,换句话说,一个变量有名称、类型和值。一个变量有一个名称,例如radius、area、age和height,每个变量的名称都是唯一的,这边可以方便我们设置和获取变量的值。
我们简单的拿生活中的旅馆来举例
旅馆中的房间 变量
房间名称 变量名
房间类型 变量类型
入住的客人 变量的值
通过变量名可以简单快速的找到他存储的数据。将数据指定给变量,就是将数据存储到以别名为变量名的那个房间;调用变量,就是将那个房间中的数据取出来使用。可见,变量是存储数据的一个基本单元,不同的变量相互独立。
一个变量有一种类型,下面是Java类型的列子:
int: 表示整数例如123和-456
double: 表示浮点数例如3.1416、-55.66、1.2e3和-4.5E-6
String: 表示文本例如"Hello"、"Good Morning!",文本通常嵌入在双引号里面
char: 表示单个字符例如'a','8',单个字符通常嵌入在单引号里面。
变量存储特定类型的值,编程中要特别注意变量类型,举例:一个int变量存储整数123,但是不能存储浮点数12.34,同样也不能存储文本"Hello"。
早期的编程语言中引入了类型的概念来解释二进制01数据,类型定义了数据的结构、大小、范围以及针对该类型的一系列操作。
2.名称
标识由大小写字母、数字、下划线和$的任意长度的字符序列组成。
空白 (空格、制表符、换行符)和其他特殊字符 (如+ - * / @ &, 等)是不允许的,错误的命名方式:max value和max-value。
标识符不能以数字(0-9)开头必须以字母(a-z, A-Z)、下划线(_)和$开头,系统保留以$开头的标识。
标识符不能使用关键字和预留字段 (例如:class,int,double,if,else,for,true,false,null)。
标识符是区分大小写的,rose、Rose和ROSE是3个不同的变量。
Java中八种常用数据类型:
int,double,short,float,boolean,byte,long,char
字节:
数字,英文(无论大小写),英文标点都占用一个字节
汉子,中文的标点符号占用两个字节
内存:
计算机使用内存来存储计算时所需要的数据
创建变量的两种方式:
1.声明-->赋值-->取值
//声明变量
int money;
//存钱
//=:赋值运算符(将右边的值赋值给左边)
//赋值变量
money=1000;
//+:用于连接
//调用变量
System.out.println("存储"+":"+money);
2.声明+赋值-->取值
double price=99.99;
System.out.println(price);
常量:
//常量final:一但赋值不可改变
final int sum;
sum=3;
3.运算符
1.赋值运算符:
=:代表赋值运算符:将右边的值赋值给左边
2.算数运算符:
+:加法 a+b
-:减法 a-b
*:乘法 a*b
/:除法 a/b
%:取余 a%b
3.关系运算符:
>:大于 10>13 结果为false
<:小于 10<13 结果为true
>=:大于等于
<=:小于等于
==:等于
!=:不等于0
扫描仪:
Scanner input=new Scanner(
System.in);
导包:java.lang.util
Boolean类型:
取值:
false :假
true:真
运算符的优先级:算数运算符>关系运算符>逻辑运算符,即在一个表达式中,算数运算符的优先等级最高,关系运算符次之,然后是逻辑运算符。逻辑运算符将在下一章进行学习。如果在一个表达式中包含赋值运算符,则它的优先级最低。
计算机处理数据,变量被用来存储处理的数据,之所以叫做变量因为你可以改变存储的值。更确切的说,一个变量指向着一块存储特定类型值的地址,换句话说,一个变量有名称、类型和值。一个变量有一个名称,例如radius、area、age和height,每个变量的名称都是唯一的,这边可以方便我们设置和获取变量的值。
我们简单的拿生活中的旅馆来举例
旅馆中的房间 变量
房间名称 变量名
房间类型 变量类型
入住的客人 变量的值
通过变量名可以简单快速的找到他存储的数据。将数据指定给变量,就是将数据存储到以别名为变量名的那个房间;调用变量,就是将那个房间中的数据取出来使用。可见,变量是存储数据的一个基本单元,不同的变量相互独立。
一个变量有一种类型,下面是Java类型的列子:
int: 表示整数例如123和-456
double: 表示浮点数例如3.1416、-55.66、1.2e3和-4.5E-6
String: 表示文本例如"Hello"、"Good Morning!",文本通常嵌入在双引号里面
char: 表示单个字符例如'a','8',单个字符通常嵌入在单引号里面。
变量存储特定类型的值,编程中要特别注意变量类型,举例:一个int变量存储整数123,但是不能存储浮点数12.34,同样也不能存储文本"Hello"。
早期的编程语言中引入了类型的概念来解释二进制01数据,类型定义了数据的结构、大小、范围以及针对该类型的一系列操作。
2.名称
标识由大小写字母、数字、下划线和$的任意长度的字符序列组成。
空白 (空格、制表符、换行符)和其他特殊字符 (如+ - * / @ &, 等)是不允许的,错误的命名方式:max value和max-value。
标识符不能以数字(0-9)开头必须以字母(a-z, A-Z)、下划线(_)和$开头,系统保留以$开头的标识。
标识符不能使用关键字和预留字段 (例如:class,int,double,if,else,for,true,false,null)。
标识符是区分大小写的,rose、Rose和ROSE是3个不同的变量。
Java中八种常用数据类型:
int,double,short,float,boolean,byte,long,char
字节:
数字,英文(无论大小写),英文标点都占用一个字节
汉子,中文的标点符号占用两个字节
内存:
计算机使用内存来存储计算时所需要的数据
创建变量的两种方式:
1.声明-->赋值-->取值
//声明变量
int money;
//存钱
//=:赋值运算符(将右边的值赋值给左边)
//赋值变量
money=1000;
//+:用于连接
//调用变量
System.out.println("存储"+":"+money);
2.声明+赋值-->取值
double price=99.99;
System.out.println(price);
常量:
//常量final:一但赋值不可改变
final int sum;
sum=3;
3.运算符
1.赋值运算符:
=:代表赋值运算符:将右边的值赋值给左边
2.算数运算符:
+:加法 a+b
-:减法 a-b
*:乘法 a*b
/:除法 a/b
%:取余 a%b
3.关系运算符:
>:大于 10>13 结果为false
<:小于 10<13 结果为true
>=:大于等于
<=:小于等于
==:等于
!=:不等于0
扫描仪:
Scanner input=new Scanner(
导包:java.lang.util
Boolean类型:
取值:
false :假
true:真
运算符的优先级:算数运算符>关系运算符>逻辑运算符,即在一个表达式中,算数运算符的优先等级最高,关系运算符次之,然后是逻辑运算符。逻辑运算符将在下一章进行学习。如果在一个表达式中包含赋值运算符,则它的优先级最低。
--恢复内容开始---
变量声明及使用
示例1.
public class MyVariable{
public static void main(String[] args) {
int money = 1000; //存储本金
system.out.printly(money);
}
}
赋值运算符
示例2.
public class OperatoDemo {
public static void main(String[] args) {
int WangScore = 80; //王浩成绩
int zhangScore;
zhangScore = WangScore;
system.out.println(“张萌的成绩是”+zhangScore);
}
}
示例3.
import java.util.Scanner;
public class scorestat {
public static void main(String[] args) {
Scanner input =new Scanner(System.in);
System.out.print("stb的成绩是:")
int stb=input.nextInt();
System.out.print("java的成绩是:")
int java=input.nextInt();
System.out.print("sql的成绩是:")
int sql=input.nextInt();
int diffen;
double avg; //平均分
System.out.println("---------------------------------");
System.out.println("stb\tjava\tsql");
System.out.println("stb");
System.out.println("---------------------------------");
}
}
---恢复内容结束---
---恢复内容开始---
变量声明及使用
示例1.
public class MyVariable{
public static void main(String[] args) {
int money = 1000; //存储本金
system.out.printly(money);
}
}
赋值运算符
示例2.
public class OperatoDemo {
public static void main(String[] args) {
int WangScore = 80; //王浩成绩
int zhangScore;
zhangScore = WangScore;
system.out.println(“张萌的成绩是”+zhangScore);
}
}
示例3.
import java.util.Scanner;
public class scorestat {
public static void main(String[] args) {
Scanner input =new Scanner(System.in);
System.out.print("stb的成绩是:")
int stb=input.nextInt();
System.out.print("java的成绩是:")
int java=input.nextInt();
System.out.print("sql的成绩是:")
int sql=input.nextInt();
int diffen;
double avg; //平均分
System.out.println("---------------------------------");
System.out.println("stb\tjava\tsql");
System.out.println("stb");
System.out.println("---------------------------------");
示例1.
public class MyVariable{
public static void main(String[] args) {
int money = 1000; //存储本金
system.out.printly(money);
}
}
赋值运算符
示例2.
public class OperatoDemo {
public static void main(String[] args) {
int WangScore = 80; //王浩成绩
int zhangScore;
zhangScore = WangScore;
system.out.println(“张萌的成绩是”+zhangScore);
}
}
示例3.
import java.util.Scanner;
public class scorestat {
public static void main(String[] args) {
Scanner input =new Scanner(System.in);
System.out.print("stb的成绩是:")
int stb=input.nextInt();
System.out.print("java的成绩是:")
int java=input.nextInt();
System.out.print("sql的成绩是:")
int sql=input.nextInt();
int diffen;
double avg; //平均分
System.out.println("---------------------------------");
System.out.println("stb\tjava\tsql");
System.out.println("stb");
System.out.println("---------------------------------");
}
}
---恢复内容结束---
---恢复内容开始---
变量声明及使用
示例1.
public class MyVariable{
public static void main(String[] args) {
int money = 1000; //存储本金
system.out.printly(money);
}
}
赋值运算符
示例2.
public class OperatoDemo {
public static void main(String[] args) {
int WangScore = 80; //王浩成绩
int zhangScore;
zhangScore = WangScore;
system.out.println(“张萌的成绩是”+zhangScore);
}
}
示例3.
import java.util.Scanner;
public class scorestat {
public static void main(String[] args) {
Scanner input =new Scanner(System.in);
System.out.print("stb的成绩是:")
int stb=input.nextInt();
System.out.print("java的成绩是:")
int java=input.nextInt();
System.out.print("sql的成绩是:")
int sql=input.nextInt();
int diffen;
double avg; //平均分
System.out.println("---------------------------------");
System.out.println("stb\tjava\tsql");
System.out.println("stb");
System.out.println("---------------------------------");