java基础语言

目录

1. Java开发环境：

java编译运行过程：

名词解释：

2. 八种基本数据类型:

3. 类型间的转换：

两种方式：

两点规则：

---

1. Java开发环境：

• java编译运行过程：

  • 编译期：.java源文件，经过编译，生成.class字节码文件
  • 运行期：JVM加载.class并运行.class(0和1)
  • 特点：跨平台，一次编译到处运行

• 名词解释：

  • JVM：java虚拟机
    • 加载.class并运行.class
  • JRE：java运行环境
    • 除了包含JVM以外还包含了运行java程序所必须的环境
    • JRE = JVM+java系统类库(小零件)
  • JDK：java开发工具包
    • 除了包含JRE以外还包含了开发java程序所必须的命令工具
    • JDK = JRE+编译、运行等命令工具

        说明：

                1. 运行java程序的最小环境为JRE

                2. 开发java程序的最小环境为JDK

2. 八种基本数据类型:

 byte、short、int、long、float、double、boolean、char

• int：整型，4个字节，-21多亿到21个多亿

  • 整数直接量默认为int类型，但不能超出范围，若超范围则发生编译错误

        int a = 250; //250为整数直接量，默认为int类型
        int b = 10000000000; //编译错误，100亿默认为int类型，但超出范围了
        int c = 35.678; //编译错误，int类型只能装整数

  • 运算时若超出范围，则发生溢出，溢出不是错误，但需要避免

    int d = 2147483647; //int的最大值 
    d = d+1;
    System.out.println(d); //-2147483648(int的最小值)，发生溢出

  • 两个整数相除，结果还是整数，小数位无条件舍弃(不会四舍五入)

            System.out.println(5/2); //2 
            System.out.println(2/5); //0 
            System.out.println(5/2.0); //2.5

• long：长整型，8个字节，很大很大很大

  • 长整型直接量需在数字后加L或l

    long a = 25L; //25L为长整型直接量
    //long b = 10000000000; //编译错误，100亿默认为int类型，但超出int范围了
    long c = 10000000000L; //100亿L为长整型直接量
    //long d = 25.678; //编译错误，long类型只能装整数

  • 运算时若有可能溢出，建议在第1个数字后加L

    long e = 1000000000*2*10L;
    System.out.println(e); //200亿
    long f = 1000000000*3*10L;
    System.out.println(f); //不是300亿
    long g = 1000000000L*3*10;
    System.out.println(g); //300亿

• double：浮点型，8个字节，很大很大很大

  • 浮点数直接量默认为double类型，若想表示float，需在数字后加F或f

    double a = 3.14; //3.14为浮点数直接量，默认为double型
    float b = 3.14F; //3.14F为float型直接量

  • double和float型数据参与运算时，有可能会发生舍入误差，精确场合不能使用

double c=6.0,d=1.9;
System.out.println(c-d); //0.10000000000000009，有可能发生舍入误差

• boolean：布尔型，1个字节

  • 只能取值为true或false

boolean b1 = true; //true为布尔型直接量
boolean b2 = false; //false为布尔型直接量
//boolean b3 = 25; //编译错误，布尔型只能赋值为true或false

• char：字符型，2个字节

  • 采用的是Unicode编码格式，每个字符都对应一个码, 表现的形式为字符char，但本质上是码int(0到65535之间), ASCII码：'a'----97 ‘A'----65 '0'----48
  • 字符型直接量必须放在单引号中，只能有1个

char c1 = '女'; //字符女
char c2 = 'f'; //字符f
char c3 = '6'; //字符6
char c4 = '*'; //字符*
//char c5 = 女; //编译错误，字符直接量必须放在单引号中
//char c6 = ''; //编译错误，必须有字符
//char c7 = '10'; //编译错误，只能有一个字符
char c8 = 65; //相当于:char c8='A';
System.out.println(c8); //输出时会依据c8的类型来显示数据
//因为c8是char类型，所以会以字符的形式显示

• 特殊符号需要\来转义

char c9 = '\\'; //特殊符号需要通过\来转义
System.out.println(c9); //

3. 类型间的转换：

• 基本数据类型从小到大依次为：byte--short--int--long--float--double     char--

• 两种方式：

  • 自动/隐式类型转换：小类型到大类型
  • 强制类型转换：大类型到小类型 语法: (要转换成为的数据类型)变量

                注意：强转有可能会溢出或丢失精度

int a = 5;
long b = a; //自动/隐式类型转换
int c = (int)b; //强制类型转换
long d = 5; //自动类型转换
double e = 5; //自动类型转换
long f = 10000000000L;
int g = (int)f;
System.out.println(g); //1410065408，强转有可能发生溢出
double h = 25.987;
int i = (int)h;
System.out.println(i); //25，强转有可能丢失精度

• 两点规则：

  • 整数直接量可以直接赋值给byte,short,char，但不能超出范围
  • byte,short,char型数据参与运算时，系统一律先将其转换为int再运算

4. 运算符：

• 算术：+、-、*、/、%、++、--
  • %:取模/取余，余数为0即为整除

System.out.println(5%2); //1，商2余1
System.out.println(8%2); //0，商4余0----整除
System.out.println(2%8); //2，商0余2

• ++/--:自增1/自减1，可在变量前也可在变量后
  • 单独使用时，在前在后都一样

//++单独使用:
int a=5,b=5;
a++; //相当于a=a+1
++b; //相当于b=b+1
System.out.println(a); //6
System.out.println(b); //6
//--单独使用:
int a=5,b=5;
a--; //相当于a=a-1
--b; //相当于b=b-1
System.out.println(a); //4
System.out.println(b); //4

• 被使用时，在前在后不一样
  • a++的值为a----------(a--的值为a)
  • ++a的值为a+1--------(--a的值为a-1)

//++被使用:
int a=5,b=5;
int c = a++; //1)记录下a++的值5 2)a自增1变为6 3)将记录的5赋值给c--
了解
//简便记法:a++的值为5，所以c的值就是5
int d = ++b; //1)记录下++b的值6 2)b自增1变为6 3)将记录的6赋值给d--
了解
//简便记法:++b的值为6，所以d的值就是6
System.out.println(a); //6
System.out.println(b); //6
System.out.println(c); //5
System.out.println(d); //6
//--被使用:
int a=5,b=5;
int c = a--; //a--的值为5，所以c就是5
int d = --b; //--b的值为4，所以d就是4
System.out.println(a); //4
System.out.println(b); //4
System.out.println(c); //5
System.out.println(d); //4

• 关系：>、<、>=、<=、==、!=
  • 大于>，小于<，大于或等于>=，小于或等于<=，等于==，不等于!=
  • 关系运算的结果为boolean型，关系成立则为true，关系不成立则为false

int a=5,b=10,c=5;
boolean b1 = a>b;
System.out.println(b1); //false
System.out.println(c<b); //true
System.out.println(b>=a); //true
System.out.println(a<=c); //true
System.out.println(a==c); //true
System.out.println(a!=c); //false
System.out.println(a+c>10); //false
System.out.println(a%2==0); //false
System.out.println(a++>5); //false------a自增1变为6
System.out.println(a++>5); //true-------a自增1变为7

• 逻辑：&&、||、!
  • &&：短路与(并且)，两边都为真则为真，见false则false

                ---若第1 个条件为 false ，则发生短路 ( 后面的不执行了 )

int a=5,b=10,c=5;
boolean b1 = b>=a && b<c;
System.out.println(b1); //true&&false=false
System.out.println(b<=c && b>a); //false&&true=false
System.out.println(a==b && c>b); //false&&false=false
System.out.println(b!=c && a<b); //true&&true=true
//演示短路:
boolean b3 = a>b && c++>2;
System.out.println(b3); //false
System.out.println(c); //5，发生短路了(c++>2并没有被执行)

        ||：短路或 ( 或者 ) ，有真则为真，见 true 则 true

        ---若第 1 个条件为 true ，则发生短路 ( 后面的不执行了 )

System.out.println(b>=a || b<c); //true||false=true
System.out.println(b<=c || b>a); //false||true=true
System.out.println(b!=c || a<b); //true||true=true
System.out.println(a==b || c>b); //false||false=false
//演示短路:
boolean b4 = a<b || c++>2;
System.out.println(b4); //true
System.out.println(c); //5，发生短路了(c++>2并没有被执行)

        !：逻辑非 ( 取反 ) ，非真则假，非假则真

boolean b2 = !(a>b); //!的优先级高，所以需要将a>b括起来
System.out.println(b2); //!false=true
System.out.println(!(a<b)); //!true=false

        逻辑运算是建立在关系运算的基础之上的，逻辑运算的结果也是boolean 型

• 赋值：=、+=、-=、*=、/=、%=
  • 简单赋值运算符:=扩展赋值运算符:+=、-=、*=、/=、%=

                ---扩展赋值自带强转功能

int a = 5;
a += 10; //相当于a=(int)(a+10)
System.out.println(a); //15
a *= 2; //相当于a=(int)(a*2)
System.out.println(a); //30
a /= 6; //相当于a=(int)(a/6)
System.out.println(a); //5
//小面试题:
short s = 5;
//s = s+10; //编译错误，需强转，改为:s=(short)(s+10);
s += 10; //相当于: s=(short)(s+10);

• 字符串连接：
  • +：
  • 若两边为数字，则做加法运算
  • 若两边出现了字符串，则做字符串连接

                ---任何类型的数据与字符串相连，结果都会变为字符串类型

int age = 38;
System.out.println("age="); //age=
System.out.println(age); //38
System.out.println("age="+age); //age=38
System.out.println("我的年龄是"+age); //我的年龄是38
System.out.println("我今年"+age+"岁了"); //我今年38岁了
String name = "WKJ"; //String是字符串数据类型
System.out.println("大家好，我叫"+name); //大家好，我叫WKJ
System.out.println("大家好，我叫"+name+"，今年"+age+"岁了"); //大家
好，我叫WKJ，今年38岁了
System.out.println(10+20+""+30); //3030------String
System.out.println(""+10+20+30); //102030----String
System.out.println(10+20+30+""); //60--------String

• 条件/三目：boolean？数1：数2
  • 语法: boolean?数1:数2
  • 执行过程:
    • 整个表达式是有值的，它的值要么是?号后的数1，要么是:号后的数2
    • 计算boolean的值:
      • 若为true，则整个表达式的值为?号后的数1
      • 若为false，则整个表达式的值为:号后的数2

int num = 5;
int flag = num>0?1:-1;
System.out.println(flag); //1
int a=8,b=55;
int max = a>b?a:b;
System.out.println("max="+max);

• 2. 分支结构：基于条件执行某语句
  • if结构：1条路

1 ) 语法 :

        if ( boolean ){

                语句块 ---------- 有条件执行的语句

        }

2 ) 执行过程 :

        判断boolean 的值 :

                若为true，则执行语句块 ( if 整个结束 )

                若为false，则 if 直接结束

//1)偶数的判断:
int num = 6; //带数(6,5)
if(num%2==0){
System.out.println(num+"是偶数");
}
System.out.println("继续执行...");
//2)满500打8折:
double price = 300.0; //消费金额 带数(600.0,300.0)
if(price>=500){ //满500
price = price*0.8; //打8折
}
System.out.println("最终结算金额为:"+price);

• if...else结构：2条路

1 ) 语法 :

        if ( boolean ){

                语句块1

        } else {

                语句块2

        }

2 ) 执行过程 :

        判断boolean 的值 :

                若为true，则执行语句块 1 ( 整个结束 )

                若为false，则执行语句块 2 ( 整个结束 )

3 ) 说明 :

        语句块1 和语句块 2 ，必走其中之一 ------- 2 选 1

//1)偶数、奇数的判断:
int num = 5; //带数(6,5)
if(num%2==0){
System.out.println(num+"是偶数");
}else{
System.out.println(num+"是奇数");
}
System.out.println("继续执行...");
//2)满500打8折，不满500打9折:
double price = 300.0;
if(price>=500){ //带数(600.0,300.0)
price *= 0.8;
}else{
price *= 0.9;
}
System.out.println("最终结算金额为:"+price);