欢迎您访问程序员文章站本站旨在为大家提供分享程序员计算机编程知识!
您现在的位置是: 首页

运算符 类型转换 基本数据类型

程序员文章站 2024-03-22 14:26:40
...

复习:
jdk(开发环境)
–开发工具:编译器,解析器,javadoc.exe
–jre(java运行环境)
–jvm
–类库
配置环境变量:
JAVA_HOME:新建的
CLASSPATH:新建的
PATH:追加信息
测试:
java -version 回车
javac 回车

java的运行原理:
1.编译过程:
源文件(.java)—>字节码文件(.class)
执行:
javac 源文件名称(带扩展名)

注意:源文件只要更改,就需要重新编译
     编译过程中,会检查语法格式,
 如果格式错误,那么就不会编译成功

2.运行过程:
使jvm运行字节码文件。
执行:
java 字节码文件名称(不带扩展名)
变量:
jvm在内存中开辟的一个存储空间,用来存储数据
命名规则: (1)名称由字母,数字,_和$任意组成,数字不能开头
(2)大小写敏感
(3)可以使用汉字,但是不建议使用
(4)驼峰命名法,见名知意
myDogName = “旺财”;
(5)不能使用关键字(java保留字)

使用规则:  (1) 必须先定义(声明,创建)和初始化
    (2) 变量可以重复使用,即
         可以进行多次存取操作。
        不需要强调类型,但是存储数据时
         一定要与第一次声明时的类型匹配
    (3) 变量的作用域:变量有自己的使用范围。
         出了范围,变量失效。
         作用域:即从定义开始,
         到所在的大括号的结束符号为止。
        出了作用域:想使用,需要重新定义和
         初始化

类型:
引用类型和基本数据类型

基本数据类型中:8种
byte,short,int,long,float,double,char,boolean

整数类型:4种

byte,short,int,long

System.currentTimeMillis();会返回一个long类型的
数据。此数据为 从1970年1月1日0时0分0秒到系统当前时间之间的
所有毫秒数。

浮点数类型:2种–小数类型
float:
在内存中占4字节大小,32位二进制
范围:
-3.403E38~3.403E38
double:
在内存中占8字节大小,64位二进制
范围:
-1.79E308~1.79E308

字面量:默认类型为double,即64位的浮点数类型
如果想直接写32位的浮点数,需要在数值后
添加f/F

  比如:
   double num = 3.14;
   float num1 = 3.14F;

范围大小从大到小排序:
double>float>long>int>short>byte
精度大小从大到小排序:(int,long,float,double)

long>int>double>float

字符类型:char 单引号引起来
在内存中占2字节大小,16位二进制。
赋值特点:
(1)值中,有且只有一个字符
//char c4 = ’ ‘;//编译错误,只能为一个空格
(2)字符必须使用单引号引起来。
另外特点:底层二进制是无符号的整数类型
即 0~2^16-1—>0~65535
所以,赋值时,也可以赋值整数。但是,存入变量
空间后,其实是其整数对应的字符。

java语言默认使用的字符集为unicode。
unicode字符集:
无论字母,还是汉字,都占两个字节大小
‘A’—00000000 01000001
‘a’—00000000 01100001
‘0’—00000000 00110000
什么是字符集:
即二进制与字符的一一对应关系的表

GBK
GBK2312
UTF-8
‘中’—-00010110 01010101
‘中’—-00010110 01010101 00010001

写文件时:采用unicode输入’中’
00010110 01010101
打开文件时:采用GBK
00010110 01010101—-好

  编码:将字符--->二进制
        写
  解码:将二进制--->字符
        读

java语言常用的字符:
‘A’~’Z’ ->65~90
‘a’~’z’ ->97~122
‘0’~’9’ ->48~57

java语言中的转义字符:
‘\’:将特殊字符变成相应意义的字符。
java语言中的特殊字符:
单引号,双引号,制表符,换行符,回车符号
‘\” 单引号
‘\”’ 双引号
‘\’ 反斜线
‘\t’ 制表符
‘\r’ 换行符,(有翻页效果,看不到上一页的数据)
‘\n’ 回车符,

需求:查看字符集中,某一字符对应的整数
将字符赋值给int类型的变量即可
int num = ‘王’;
int num1 = ‘从’;
int num2 = ‘明’;
char c20 = 65;

布尔类型:用来判断条件是否成立的。
在内存中占1字节大小。
只有两个值 true/false
true:表示条件成立

false:表示条件不成立

类型转换:
1.自动转换(隐式转换)
占内存小的类型变量赋值给占内存大的类型变量,
会发生自动转换。

 byte b = 5;
 short b1 = b;//8位的5赋值给16位5,在前面自动添8个0

 int  c1 = -1;
 long c2 = c1;//32位的-1赋值给了64位的c2里,自动填了32个11

 long c3 = -1;

 byte-->short-->int-->long-->float-->double
        char

2、强制转换:
占内存大的类型变量赋值给占内存小的类型变量,需要
强制转换。语法如下:
(占内存小的变量类型名)变量;
注意:有可能出现精度损失。

例: int a = 1;
     byte a1 = (byte)a;


 例:long b = -10;
     int  b1 = (int)b;

 double->float-->long-->int-->short--byte
                          char

===============================
引用类型之一
String:字符串类型

赋值特点:
      1.必须使用双引号
      2.引号内有0或0个以上的字符都可
      3.字符串可以做拼接操作,拼接后的数据
        仍是字符串类型。

================================
运算符:
两原一封:
两个原则:
1、不同类型的数据做运算时,一定会先转换成较大范围类型后
再运算。
2、byte,short,char这些类型运算时,一定会先转成
int类型再运算,结果int类型
封:
int long 一定要注意封闭式运算。

算术运算符:
+,-,*,/,%,++,–

 /:
    情况1:
参与的类型都是整型时,做取整运算,
  即 商n余m, 结果为n
    2/3----商0余2。结果为0
    情况2:
   只要有一个浮点数参与,就会做
   类似精确运算。
 %:取余运算符号,也叫取模运算符号
     做除法运算时,商n余m,结果为m.

 情况1:参与运算都是整数时,余数是精确值
 情况2: 有浮点数参与时,余数不一定是精确值。

 注意:
 取余运算一般被用来判断 某一个数能
 否被另外一个数整除。
++/--:是自增自减运算符
    符号要与变量一起使用。
表示变量自动+1,或自动-1;
如:++a/a++/--a/a--;
   ++a/a++:是a=a+1的简写
   --a/a--:是a=a-1的简写

 情况1: 即与变量在一起,不与其他任何符号连用时
        (单独使用)
    ++a
    a++
    --a
    a--
    此时,变量一定会+1或-1;

 情况2:自增/自减运算与其他符号连用时
       需要考虑表达式的值。
   ++a/a++/--a/a--整体看成表达式

       口诀:
       符号在前,先运算再赋值
       符号在后,先赋值在运算

    解析:符号在前时,变量先自增/自减,新值赋值给表达式
          符号在后时,先把变量的值赋值给表达式,然后变量再自增/自减

   如:
   int a = 1;
   a = ++a;
   System.out.println(a);

例1. 字符类型的学习 凡是能用书写工具写出来的,都是字符,
包括空格,换行符,制表符。

public static void main(String[] args){
    char c1 = 'a';
    System.out.println(c1);  //a
    char c2 = '啊';
    System.out.println(c2);  //啊
    //char c3 = '';//编译错误,不能为空
    char c3 = ' ';//编译正确,可以为空格
    //char c4 = '  ';//编译错误,只能为一个空格
    //char c5 = "b";//编译错误,只能使用单引号
    System.out.println("------分割线------");
    char c6 = 20013;
    char c7 = 20101;
    System.out.println(c6);//中
    System.out.println(c7);//亅
    char c8 = 65;
    char c9 = 97;
    char c10 = 48;
    System.out.println(c8);//A
    System.out.println(c9);//a
    System.out.println(c10);//0
    System.out.println("---------特殊字符分割线---------");
    char c11 = '\\';
    System.out.println(c11);// \
    char c12 = '\'';
    System.out.println(c12);// '
    char c13 = '\"';
    System.out.println(c13);// "
    char c14 = '\t';
    System.out.println("姓名"+c14+"年龄");// (制表)姓名    年龄
    System.out.println("小"+c14+"12");//小      12
    System.out.println();
    System.out.println("hello\rworld");//(分页 看不到上一行)world
    System.out.println("中国\n最伟大");//(换行)中国

最伟大
System.out.println(“——–分割线———-“);
int num = ‘高’;//39640
int n1 = ‘圆’;//22278
int n2 = ‘我’;//25105
int n3 = ‘爱’;//29233
int n4 = ‘你’;//20320
System.out.println(num);
System.out.println(n1);
System.out.println(n2);
System.out.println(n3);
System.out.println(n4);
System.out.println(“——-分割线——”);
boolean f1 = true;
boolean f2 = false;
System.out.println(f1);//true
System.out.println(f2);//false
int age1 = 33;
int age2 = 54;
boolean f3 = age1>age2;
System.out.println(f3);//false
boolean f4 = age1<=age2;
System.out.println(f4);//true
}

例2. 类型转换:
自动转换(隐式转换)
强制转换(显式转换)

public static void main(String[] args){
  /*
    练习:
      将 short类型的b赋值给int类型的a;
      将 byte类型的c赋值给double类型的d;
      将float类型的e赋值给double类型的g;

      将double类型的n1赋值给float类型的n2
      将float类型的n2赋值给int类型的n3;
      将int类型的n3赋值给byte类型的n4;
      分别输出
  */
    short b = 10;
    int a = b;
    System.out.println(a);//10
    byte c = 100;
    double d = c;
    System.out.println(d);//100.0
    float e = 1.0F;
    double g = e;
    System.out.println(g);//1.0

    double n1 = 0.618;
    float n2 = (float)n1;
    int n3 = (int)n2;
    byte n4 = (byte)n3;
    System.out.println(n2);//0.618
    System.out.println(n3);//0
    System.out.println(n4);//0
}

例3. 字符串类型:String

public static void main(String[] args){
    /*字符串类型:String
      赋值特点:
      1.必须使用双引号
      2.引号内有0或0个以上的字符都可
      3.字符串可以做拼接操作,拼接后的数据
        仍是字符串类型。
    */
    String name = "小张";
    //String n1 = '小王';//编译错误。
    String n1 = "";//编译正确,可以为空字符串
    String n2 = " ";//编译正确,空格字符串
    String m = "中国";
    String m1 = "666";
    //可以进行拼接操作,拼接符号为 +
    String m2 = m+m1;
    System.out.println(m2);//中国666

    int count = 777;
    String result = m+count;//中国777
    System.out.println(result);
    System.out.println(3+2+"中国");//"5中国"
    System.out.println(3+"+"+2+"="+(3+2));//3+2=5
    System.out.println(3+3+"3"+3*3);//"639"
    /*
      在做运算时,+前后只要有一个是字符串类型
      就会做拼接操作。结果是字符串类型
    */
}

例4.
public static void main(String[] args){
/*
计算 10亿*3,输出结果
计算 10亿+10亿+10亿,输出结果
计算 10亿*3L,输出结果
计算 10亿L+10亿+10亿,输出结果
*/
int a = 1000000000*3;
System.out.println(a);
int b = 1000000000+1000000000+1000000000;
System.out.println(b);
long c = 1000000000*3L;
System.out.println(c);
long d = 1000000000L+1000000000+1000000000;
System.out.println(d);
/*
System.currentTimeMillis();会返回一个
long类型的数据。此数据为
从1970年1月1日0时0分0秒到系统当前时间之间
的所有毫秒数。
*/
long time = System.currentTimeMillis();
System.out.println(time);
/*
将time的值换算成年份,+1970
*/
long num = time/1000/60/60/24/365;
System.out.println(num+1970);
}

例5. 算术运算符:
+,-,*,/,%,++,–

强制转换


public static void main(String[] args){
    byte a = 1;
    byte b = 2;
    byte c = (byte)(a+b);//a+b的结果为int类型,再强制转换成byte类型

    short s1 = 1;
    char c1 = 'A';
    int result = s1+c1;//两个变量都先变成int类型,再运算
    System.out.println(result);
    short s2 = (short)(s1+c1);
    char  c2 = (char)(s1+c1);
    System.out.println(s2);//66
    System.out.println(c2);//'B'

    int m1 = 10;
    long m2 = -1;
    long m3 = m1-m2;//m1转成long再与m2运算
    System.out.println(m3);//11

    int n1 = 10;
    double n2 = 2;
    double n3 = n1*n2;
    System.out.println(n3);//20.0

    int x1 = 10;
    int x2 = 3;
    int x3 = x1/x2;
    System.out.println(x3);//3
    x3 = x2/x1;
    System.out.println(x3);//0

    long x4 = x2/10L;
    System.out.println(x4);

    double x5 = 2.5;
    long  x6 = 5;
    double x7 = x6/x5;
    System.out.println(x7);
    double x8 = 3.1415926;
    int x9 = 2;
    double x10 = x8/x9;
    System.out.println(x10);
    System.out.println("------取余分割线----");

    int y1 = 3;
    int y2 = 10;
    int y3 = y1%y2;
    System.out.println(y3);//3
    y3 = y2%y1;
    System.out.println(y3);//1

    float y4 = 2.7f;
    float y5 = y4%y1;
    System.out.println(y5);//2.7
    y5 = y1%y4;
    System.out.println(y5);
    System.out.println("------自增自减分割线------");
    //情况1:
    int z = 1;
    ++z;
    System.out.println(z);//2
    z++;
    System.out.println(z);//3
    --z;
    System.out.println(z);//2
    z--;
    System.out.println(z);//1
    //情况2:
    int q = 1;
    int v = ++q;
    System.out.println(v);//2
    q = 1;
    v = q++;
    System.out.println(v);//1

    q = 10;
    v = --q;
    System.out.println(v);//9
    q = 100;
    v = q--;
    System.out.println(v);//100

    /*
      int w = 10;
      int p = 5;
  表达式:10     12    5     3    12
    变量:11     12    4     3
      w = w++ + ++w + p-- + --p - w;

      System.out.println(w);
      System.out.println(p);//3

    */
}

例6. 浮点数类型的学习
float,double
数值字面量为double类型,
直接写float类型的数值时,需要添加F/f

public static void main(String[] args){
    /* 浮点数赋值方式:
       3.14;  1.2E2;  .512
    */
    double a = 3.14;
    System.out.println(a);
    double b = 1.2e2;
    System.out.println(b);
    double c = .512;
    System.out.println(c);
    double d = .123E2;
    System.out.println(d);
    float  h = 3.14f;
    System.out.println(h);
    //float  i = .512FE2;//错误写法
    float  j = .521E2F;//正确写法
    System.out.println(j);
    /*
    将数值1.1234567890123456789分别存入
    float的变量m中和double的变量n中,
    然后输出,查看结果。

    发现:
      浮点数类型在存储数据时,会有舍入误差
      即,不够精确。但是,double要比float
      更精确一些(相比float,要精确多一倍)

    double:双精度浮点数类型
    float:单精度浮点数类型
    */
    float m = 1.1234567890123456789F;
    double n = 1.1234567890123456789;
    System.out.println(m);
    System.out.println(n);
    /*
      浮点数类型无法精准表示1/10,就像10进制数
      无法表示1/3一样。
      所以,在运算时,多数情况下,都是不精确
      运算
    */
    double n1 = 3.15;
    double n2 = 2.5;
    double n3 = n1-n2;
    System.out.println(n3);


}

复习:
jdk(开发环境)
–开发工具:编译器,解析器,javadoc.exe
–jre(java运行环境)
–jvm
–类库
配置环境变量:
JAVA_HOME:新建的
CLASSPATH:新建的
PATH:追加信息
测试:
java -version 回车
javac 回车

java的运行原理:
1.编译过程:
源文件(.java)—>字节码文件(.class)
执行:
javac 源文件名称(带扩展名)

注意:源文件只要更改,就需要重新编译
     编译过程中,会检查语法格式,
 如果格式错误,那么就不会编译成功

2.运行过程:
使jvm运行字节码文件。
执行:
java 字节码文件名称(不带扩展名)
变量:
jvm在内存中开辟的一个存储空间,用来存储数据
命名规则: (1)名称由字母,数字,_和$任意组成,数字不能开头
(2)大小写敏感
(3)可以使用汉字,但是不建议使用
(4)驼峰命名法,见名知意
myDogName = “旺财”;
(5)不能使用关键字(java保留字)

使用规则:  (1) 必须先定义(声明,创建)和初始化
    (2) 变量可以重复使用,即
         可以进行多次存取操作。
        不需要强调类型,但是存储数据时
         一定要与第一次声明时的类型匹配
    (3) 变量的作用域:变量有自己的使用范围。
         出了范围,变量失效。
         作用域:即从定义开始,
         到所在的大括号的结束符号为止。
        出了作用域:想使用,需要重新定义和
         初始化

类型:
引用类型和基本数据类型

基本数据类型中:8种
byte,short,int,long,float,double,char,boolean

整数类型:4种

byte,short,int,long

System.currentTimeMillis();会返回一个long类型的
数据。此数据为 从1970年1月1日0时0分0秒到系统当前时间之间的
所有毫秒数。

浮点数类型:2种–小数类型
float:
在内存中占4字节大小,32位二进制
范围:
-3.403E38~3.403E38
double:
在内存中占8字节大小,64位二进制
范围:
-1.79E308~1.79E308

字面量:默认类型为double,即64位的浮点数类型
如果想直接写32位的浮点数,需要在数值后
添加f/F

  比如:
   double num = 3.14;
   float num1 = 3.14F;

范围大小从大到小排序:
double>float>long>int>short>byte
精度大小从大到小排序:(int,long,float,double)

long>int>double>float

字符类型:char 单引号引起来
在内存中占2字节大小,16位二进制。
赋值特点:
(1)值中,有且只有一个字符
//char c4 = ’ ‘;//编译错误,只能为一个空格
(2)字符必须使用单引号引起来。
另外特点:底层二进制是无符号的整数类型
即 0~2^16-1—>0~65535
所以,赋值时,也可以赋值整数。但是,存入变量
空间后,其实是其整数对应的字符。

java语言默认使用的字符集为unicode。
unicode字符集:
无论字母,还是汉字,都占两个字节大小
‘A’—00000000 01000001
‘a’—00000000 01100001
‘0’—00000000 00110000
什么是字符集:
即二进制与字符的一一对应关系的表

GBK
GBK2312
UTF-8
‘中’—-00010110 01010101
‘中’—-00010110 01010101 00010001

写文件时:采用unicode输入’中’
00010110 01010101
打开文件时:采用GBK
00010110 01010101—-好

  编码:将字符--->二进制
        写
  解码:将二进制--->字符
        读

java语言常用的字符:
‘A’~’Z’ ->65~90
‘a’~’z’ ->97~122
‘0’~’9’ ->48~57

java语言中的转义字符:
‘\’:将特殊字符变成相应意义的字符。
java语言中的特殊字符:
单引号,双引号,制表符,换行符,回车符号
‘\” 单引号
‘\”’ 双引号
‘\’ 反斜线
‘\t’ 制表符
‘\r’ 换行符,(有翻页效果,看不到上一页的数据)
‘\n’ 回车符,

需求:查看字符集中,某一字符对应的整数
将字符赋值给int类型的变量即可
int num = ‘王’;
int num1 = ‘从’;
int num2 = ‘明’;
char c20 = 65;

布尔类型:用来判断条件是否成立的。
在内存中占1字节大小。
只有两个值 true/false
true:表示条件成立

false:表示条件不成立

类型转换:
1.自动转换(隐式转换)
占内存小的类型变量赋值给占内存大的类型变量,
会发生自动转换。

 byte b = 5;
 short b1 = b;//8位的5赋值给16位5,在前面自动添8个0

 int  c1 = -1;
 long c2 = c1;//32位的-1赋值给了64位的c2里,自动填了32个11

 long c3 = -1;

 byte-->short-->int-->long-->float-->double
        char

2、强制转换:
占内存大的类型变量赋值给占内存小的类型变量,需要
强制转换。语法如下:
(占内存小的变量类型名)变量;
注意:有可能出现精度损失。

例: int a = 1;
     byte a1 = (byte)a;


 例:long b = -10;
     int  b1 = (int)b;

 double->float-->long-->int-->short--byte
                          char

===============================
引用类型之一
String:字符串类型

赋值特点:
      1.必须使用双引号
      2.引号内有0或0个以上的字符都可
      3.字符串可以做拼接操作,拼接后的数据
        仍是字符串类型。

================================
运算符:
两原一封:
两个原则:
1、不同类型的数据做运算时,一定会先转换成较大范围类型后
再运算。
2、byte,short,char这些类型运算时,一定会先转成
int类型再运算,结果int类型
封:
int long 一定要注意封闭式运算。

算术运算符:
+,-,*,/,%,++,–

 /:
    情况1:
参与的类型都是整型时,做取整运算,
  即 商n余m, 结果为n
    2/3----商0余2。结果为0
    情况2:
   只要有一个浮点数参与,就会做
   类似精确运算。
 %:取余运算符号,也叫取模运算符号
     做除法运算时,商n余m,结果为m.

 情况1:参与运算都是整数时,余数是精确值
 情况2: 有浮点数参与时,余数不一定是精确值。

 注意:
 取余运算一般被用来判断 某一个数能
 否被另外一个数整除。
++/--:是自增自减运算符
    符号要与变量一起使用。
表示变量自动+1,或自动-1;
如:++a/a++/--a/a--;
   ++a/a++:是a=a+1的简写
   --a/a--:是a=a-1的简写

 情况1: 即与变量在一起,不与其他任何符号连用时
        (单独使用)
    ++a
    a++
    --a
    a--
    此时,变量一定会+1或-1;

 情况2:自增/自减运算与其他符号连用时
       需要考虑表达式的值。
   ++a/a++/--a/a--整体看成表达式

       口诀:
       符号在前,先运算再赋值
       符号在后,先赋值在运算

    解析:符号在前时,变量先自增/自减,新值赋值给表达式
          符号在后时,先把变量的值赋值给表达式,然后变量再自增/自减

   如:
   int a = 1;
   a = ++a;
   System.out.println(a);

例1. 字符类型的学习 凡是能用书写工具写出来的,都是字符,
包括空格,换行符,制表符。

public static void main(String[] args){
    char c1 = 'a';
    System.out.println(c1);  //a
    char c2 = '啊';
    System.out.println(c2);  //啊
    //char c3 = '';//编译错误,不能为空
    char c3 = ' ';//编译正确,可以为空格
    //char c4 = '  ';//编译错误,只能为一个空格
    //char c5 = "b";//编译错误,只能使用单引号
    System.out.println("------分割线------");
    char c6 = 20013;
    char c7 = 20101;
    System.out.println(c6);//中
    System.out.println(c7);//亅
    char c8 = 65;
    char c9 = 97;
    char c10 = 48;
    System.out.println(c8);//A
    System.out.println(c9);//a
    System.out.println(c10);//0
    System.out.println("---------特殊字符分割线---------");
    char c11 = '\\';
    System.out.println(c11);// \
    char c12 = '\'';
    System.out.println(c12);// '
    char c13 = '\"';
    System.out.println(c13);// "
    char c14 = '\t';
    System.out.println("姓名"+c14+"年龄");// (制表)姓名    年龄
    System.out.println("小"+c14+"12");//小      12
    System.out.println();
    System.out.println("hello\rworld");//(分页 看不到上一行)world
    System.out.println("中国\n最伟大");//(换行)中国

最伟大
System.out.println(“——–分割线———-“);
int num = ‘高’;//39640
int n1 = ‘圆’;//22278
int n2 = ‘我’;//25105
int n3 = ‘爱’;//29233
int n4 = ‘你’;//20320
System.out.println(num);
System.out.println(n1);
System.out.println(n2);
System.out.println(n3);
System.out.println(n4);
System.out.println(“——-分割线——”);
boolean f1 = true;
boolean f2 = false;
System.out.println(f1);//true
System.out.println(f2);//false
int age1 = 33;
int age2 = 54;
boolean f3 = age1>age2;
System.out.println(f3);//false
boolean f4 = age1<=age2;
System.out.println(f4);//true
}

例2. 类型转换:
自动转换(隐式转换)
强制转换(显式转换)

public static void main(String[] args){
  /*
    练习:
      将 short类型的b赋值给int类型的a;
      将 byte类型的c赋值给double类型的d;
      将float类型的e赋值给double类型的g;

      将double类型的n1赋值给float类型的n2
      将float类型的n2赋值给int类型的n3;
      将int类型的n3赋值给byte类型的n4;
      分别输出
  */
    short b = 10;
    int a = b;
    System.out.println(a);//10
    byte c = 100;
    double d = c;
    System.out.println(d);//100.0
    float e = 1.0F;
    double g = e;
    System.out.println(g);//1.0

    double n1 = 0.618;
    float n2 = (float)n1;
    int n3 = (int)n2;
    byte n4 = (byte)n3;
    System.out.println(n2);//0.618
    System.out.println(n3);//0
    System.out.println(n4);//0
}

例3. 字符串类型:String

public static void main(String[] args){
    /*字符串类型:String
      赋值特点:
      1.必须使用双引号
      2.引号内有0或0个以上的字符都可
      3.字符串可以做拼接操作,拼接后的数据
        仍是字符串类型。
    */
    String name = "小张";
    //String n1 = '小王';//编译错误。
    String n1 = "";//编译正确,可以为空字符串
    String n2 = " ";//编译正确,空格字符串
    String m = "中国";
    String m1 = "666";
    //可以进行拼接操作,拼接符号为 +
    String m2 = m+m1;
    System.out.println(m2);//中国666

    int count = 777;
    String result = m+count;//中国777
    System.out.println(result);
    System.out.println(3+2+"中国");//"5中国"
    System.out.println(3+"+"+2+"="+(3+2));//3+2=5
    System.out.println(3+3+"3"+3*3);//"639"
    /*
      在做运算时,+前后只要有一个是字符串类型
      就会做拼接操作。结果是字符串类型
    */
}

例4.
public static void main(String[] args){
/*
计算 10亿*3,输出结果
计算 10亿+10亿+10亿,输出结果
计算 10亿*3L,输出结果
计算 10亿L+10亿+10亿,输出结果
*/
int a = 1000000000*3;
System.out.println(a);
int b = 1000000000+1000000000+1000000000;
System.out.println(b);
long c = 1000000000*3L;
System.out.println(c);
long d = 1000000000L+1000000000+1000000000;
System.out.println(d);
/*
System.currentTimeMillis();会返回一个
long类型的数据。此数据为
从1970年1月1日0时0分0秒到系统当前时间之间
的所有毫秒数。
*/
long time = System.currentTimeMillis();
System.out.println(time);
/*
将time的值换算成年份,+1970
*/
long num = time/1000/60/60/24/365;
System.out.println(num+1970);
}

例5. 算术运算符:
+,-,*,/,%,++,–

强制转换


public static void main(String[] args){
    byte a = 1;
    byte b = 2;
    byte c = (byte)(a+b);//a+b的结果为int类型,再强制转换成byte类型

    short s1 = 1;
    char c1 = 'A';
    int result = s1+c1;//两个变量都先变成int类型,再运算
    System.out.println(result);
    short s2 = (short)(s1+c1);
    char  c2 = (char)(s1+c1);
    System.out.println(s2);//66
    System.out.println(c2);//'B'

    int m1 = 10;
    long m2 = -1;
    long m3 = m1-m2;//m1转成long再与m2运算
    System.out.println(m3);//11

    int n1 = 10;
    double n2 = 2;
    double n3 = n1*n2;
    System.out.println(n3);//20.0

    int x1 = 10;
    int x2 = 3;
    int x3 = x1/x2;
    System.out.println(x3);//3
    x3 = x2/x1;
    System.out.println(x3);//0

    long x4 = x2/10L;
    System.out.println(x4);

    double x5 = 2.5;
    long  x6 = 5;
    double x7 = x6/x5;
    System.out.println(x7);
    double x8 = 3.1415926;
    int x9 = 2;
    double x10 = x8/x9;
    System.out.println(x10);
    System.out.println("------取余分割线----");

    int y1 = 3;
    int y2 = 10;
    int y3 = y1%y2;
    System.out.println(y3);//3
    y3 = y2%y1;
    System.out.println(y3);//1

    float y4 = 2.7f;
    float y5 = y4%y1;
    System.out.println(y5);//2.7
    y5 = y1%y4;
    System.out.println(y5);
    System.out.println("------自增自减分割线------");
    //情况1:
    int z = 1;
    ++z;
    System.out.println(z);//2
    z++;
    System.out.println(z);//3
    --z;
    System.out.println(z);//2
    z--;
    System.out.println(z);//1
    //情况2:
    int q = 1;
    int v = ++q;
    System.out.println(v);//2
    q = 1;
    v = q++;
    System.out.println(v);//1

    q = 10;
    v = --q;
    System.out.println(v);//9
    q = 100;
    v = q--;
    System.out.println(v);//100

    /*
      int w = 10;
      int p = 5;
  表达式:10     12    5     3    12
    变量:11     12    4     3
      w = w++ + ++w + p-- + --p - w;

      System.out.println(w);
      System.out.println(p);//3

    */
}

例6. 浮点数类型的学习
float,double
数值字面量为double类型,
直接写float类型的数值时,需要添加F/f

public static void main(String[] args){
    /* 浮点数赋值方式:
       3.14;  1.2E2;  .512
    */
    double a = 3.14;
    System.out.println(a);
    double b = 1.2e2;
    System.out.println(b);
    double c = .512;
    System.out.println(c);
    double d = .123E2;
    System.out.println(d);
    float  h = 3.14f;
    System.out.println(h);
    //float  i = .512FE2;//错误写法
    float  j = .521E2F;//正确写法
    System.out.println(j);
    /*
    将数值1.1234567890123456789分别存入
    float的变量m中和double的变量n中,
    然后输出,查看结果。

    发现:
      浮点数类型在存储数据时,会有舍入误差
      即,不够精确。但是,double要比float
      更精确一些(相比float,要精确多一倍)

    double:双精度浮点数类型
    float:单精度浮点数类型
    */
    float m = 1.1234567890123456789F;
    double n = 1.1234567890123456789;
    System.out.println(m);
    System.out.println(n);
    /*
      浮点数类型无法精准表示1/10,就像10进制数
      无法表示1/3一样。
      所以,在运算时,多数情况下,都是不精确
      运算
    */
    double n1 = 3.15;
    double n2 = 2.5;
    double n3 = n1-n2;
    System.out.println(n3);


}