signed

QiShunwang

“诚信为本、客户至上”

Java零基础01-jdk的基本程序结构

2021/4/26 14:16:32   来源:

/*
1.java环境配置
2.java编程基础
    标识符
    关键字
    字面值
    变量
    数据类型
    运算符
    控制语句


*/


第一章  java环境配置
1.    public 公开的
    static 静态
    void 空
    main 方法 (String []args) (形式参数列表)

main方法 程序的入口

    public static void main (String []args)    //类体 (args是String的形式参数(形参 实参
{
    System.out.println  //方法体


}


2. public class 和class的区别
    * 可以有多个class  文件中不一定有public class (不是必须要写public class
    * 一个class会有一个xxx.class字节码文件
    * 一个java源文件中public class(定义公开类)只能有一个,且公开类名与源文件一致
        public class k  即k.java
    
    * 执行程序必须有main方法

3.Java的加载与执行:一个完整的java程序
    1.jdk自带的javac.exe编译符合语法的java源文件 成为 java.class字节码文件
    2.打开DOS命令窗口执行java.class文件
        * java.exe命令会启动JVM
        * JVM启动之后会启动类加载器ClassLoader
        * ClassLoader会在硬盘上的某个位置搜索 xxx.class字节码文件
        * 找到该文件则执行 找不到该文件则报错

4.path环境变量
Windows系统,告知系统运行一个程序的完整路径,会在path路径下寻找程序的路径
        
第二章 java编程基础

1.标识符
    所有可以自由命名的都是标识符(类名 接口名 方法名 变量名
    (规范 不属于语法 不遵守编译器不报错

    a)数字,字母,下划线和美元
    b)不能以数字开头 严格区分大小写
    c)类名 接口名首字母大写
       方法名 变量 首字母小写 后面单词首字母大写
       常量名 全部大写
       遵循驼峰规范 UserService

    public class IdentifierTest01
    {
        public void doSome()
        {
        }
    }

2.关键字(均小写

class extends implements interface import
package break case continue default
do if else for return
switch while false true null
boolean byte char short int
long float double try catch
throw throws finally abstract fianl
native private protected public static
synchronized transient volatile instanceof new
super void assert enum goto
const


3.字面值
    -就是数据 
    是java源程序的组成之一,标识符 关键字也是

    *数据类型 
    整数型 浮点型 布尔型 字符 字符串 
    'A' 字符型  只能有一个字符
    "中国" 字符串 

4.变量
    -存储数据的基本单元
    本质是内存空间:数据类型、名字、字面值
    
    -int i inHome//变量首字母小写,后面首字母大写
    int i = 10;
    * = 等号是一个运算符,赋值运算符,右运算符,右边结果赋予左边

    -有了变量,内存可以重复使用

    -读取:get
     修改:set

    -变量必须先声明,再赋值,才能访问(只申明不赋值,内存未开辟出来,变量i未初始化,不能访问
public class Test02{

    public static void main(String []args){ //main 方法作用域
        int i; // 申明i,变量还未初始化 不能访问

        i = 10;// 赋值 ,完成初始化,可以访问,内存开辟

        System.out.println(i);

        // int a,b,c = 300; (能申明变量abc,但赋值只能赋给 c = 300

        ------------------------------------------------
        int i = 100;

        i =200; //重新赋值
        int i =200; //语法错误 ,已经开辟过变量i的内存空间(等于变量名重名了

    }
}

    *变量作用域 大括号{}
    -for (int a =0; a < 10; a++){} //for循环结束,a无法访问

    -int a = null;
     for (int a =0; a < 10; a++){} //for循环结束,a可以访问

    *变量分类
    - 局部变量:方法体内的变量
         
    - 成员变量:方法体外,类体内

    不同作用域中,变量名可以相同

5.数据类型
* 基本数据类型  和  引用数据类型(字符串 类 接口 数组

基本数据类型:
    整数型:byte short int long  
    浮点型:float double 
    布尔型:boolean
    字符型:char
    
    -字符型'A'
    -字符串"ABC" 属于引用数据类型

    基本数据类型              占用空间大小(字节(1 byte = 8bit (一个比特位表示一个二进制:1/0
    ---------------------------------------------
    byte                1
    short                           2
    int                4
    long                            8

    float                4
    double                8

    boolean                1
    
    char                2

    *计算机在任何时刻都只能识别二进制。(接通 断开 

    *取值范围 “符号位”在最左边 0为正数 1为负数

    *十进制 和 二进制转化

      十进制:   128 64 32 16 8 4 2 1
      二进制:   1    1 1  1  1 1 1 1  =   255
             1    1 1  1  1 1 1 0  =   254

      具体怎么存储与 原码 反码 补码(计算机底层原理

    * byte :  -128 ~ 127(01111111  2的7次方-1   256个不同数字(256个不同二进制

    * 字符编码:ACSII码 (人为定制的字符与二进制转换的对照表

    'a' --> 97 [01100001]
    'A' --> 65
    '0' --> 48 

    'a' --解码--> [01100001]

    [01100001] --编码--> 'a'  (采用同一套对照表 不会出现乱码
        
    *    支持西欧的SO-8859-1 (latin-1
        支持中文的编码方式 GB2312 < GBK < GB18030
        支持繁体中文的 :大五码 <big5>

        Unicode 统一了全世界上的所有文字编码(UTF-8(统一编码方式,用的最多), UTF-16,UTF-32
    
    -Java用的是Unicode编码方式,所以标识符可以写中文


    八种数据类型取值范围:
        
    类型                    取值范围        
    ------------------------------------------------
    byte                    [-128 ~ 127]
    short                    [-32768 ~ 32767]
    int                    [-2147483648 ~ 2147483647]
    long
    float
    double
    boolean                    true / false
    char                    [0 ~ 65535]
    

    *short 和 char 取值范围一样,65536个数,256的平方,只是char没有负数

*默认值
        
    类型                    默认值        
    ------------------------------------------------
    byte short int long             0
    float double                0.0
    boolean                    false  [C语言中 false是0 true是1
    char                    \u000

public class DateType{
    
    static int k  = 1000;
    static int f; // 成员变量,没有手动赋值会有系统赋予的默认值,局部变量不会

    public static void main(String []args)

    {
        System.out.println(k);
        System.out.println(f); // f = 0
    }

}


5.1. char类型
    
*    转义字符 \ (在java中具有转义功能(出现在特殊字符前 将特殊字符转换成普通字符

    '\n'换行符 
    '\t'制表符 (Tab键 (制表符和空格类似 但是ASCII码不一样

    在控制台上输出“反斜杠字符\” 
    char k = '\' ;    // 反斜杠\将右边'转义成 不具备特殊含义的单引号
    char k = '\\';      //  第一个反斜杠将 第二个反斜杠 转译成 不具备转义功能的反斜杠

    在控制台上输出一个普通的单引号字符
    char a ='';   char a = '''; //编译报错

    char a ='\'';  //反斜杠转义成普通字符


    System.out.println("Hello")
    System.out.println("“Hello”")  //中文双引号
    System.out.println("\"Hello\"")  // \转义""


    char m = '中';
    //JDK中自带native2ascii.exe命令,可以将文字转换成unicode编码

    char m = '\u4e2d'; // '中'对应的unicode编码为 4e2d (\u表示后面为unicode编码


十进制
二进制:0 10 11 100 101....
十六进制:0 1 2 3 4 5 6 7 8 9 a b c d e f 10 11 12 13 14 15 16 17 18 19 1a 1b 1c 1d 1e 1f 20...
八进制:0 1 2 3 4 5 6 7 10 11 12 13 14 15 16 17 20 

5.2 整数型

* java语言中“整数型字面值”被默认作为int处理,  在“整数型字面符”后面添加 L 可当作long处理
* java有三种表示方式:  十进制   【默认
            八进制   【以0开始
            十六进制 【以0x开始

public class Datatype04
{
    public static void main(String []args)
    {
    int a =10;
    int b =010;
    int c =0x10;
    

    //输出以十进制输出
    System.out.print(a);  //10
    System.out.print(b);  //8
    System.out.print(c);  //16


    // 123整数型字面类型为int,i声明时也是int,int类型的123赋值给int类型的i变量,不存在类型转换
    int i = 123;
    
    // 456整数型字面类型为int 4个字节,x声明时为long 8个字节,int类型的456赋值给long类型的x变量
    存在类型转换
    // int小容量,long大容量,小容量转换成大容量,成为自动类型转换机制
    long x = 456;

    long y = 2147483647; //可以
    long z = 2147483648; //右边2147483648超过默认的int类型范围,编译错误
    long z = 2147483648L;
    }

}

---------------------------------------------------*

    public class Datatype05
{
    public static void main(String []args)
    {
        
        long x = 100L; // 100 由int赋值成long

        // int y = x;  // 编译错误,大容量不能直接赋值给小容量

        //强制类型转换(大容量转换成小容量 编译通过 但运行阶段可能损失精度
        int y =(int) x; 
        //强制类型转换原理
// 原始数据:00000000 00000000 00000000 00000000 00000000 00000000 00000000 01100100
// 强转后的数据:00000000 00000000 00000000 01100100
// 将左边的二进制砍掉(所有强转都是如此    
    
    
    原码:将正整数变为二进制  反码:除了符号位(最高位)其他全部取反 补码:在反码的基础上加1
    正整数的 原码 反码 补码都是相同的
    计算机运算都是以补码的方式进行计算的(如果计算结果是负数即最高位为1,转换成原码才能计算


    //精度损失比如:
    
    // 原始数据:00000000 00000000 00000000 00000000 10000000 00000000 00000000 00000000
    //强转后的数据: 10000000 00000000 00000000 00000000 (补码形式 将以上的补码转换成原码对应得到计算结果
            补码包括符号位和数值位
            此时补码 先-1 ---->再全部取反(反码)得到10000000(原补码开头为1 是负数(计算机组成原理

            正数的补码:和原码相同
            负数的补码:负数的绝对值(正整数)对应的二进制码所有二进制取反,再+1
    
    long k = 2147483648L;
    int i = (int)k;
    System.out.print(i); // -2147483648 损失精度严重

    //50是int类型,大容量;btye小容量
    byte b = 50; //但是编译可行,sun公司规定没超过byte取值范围可以,特权
    byte b = 128; //超出范围,编译报错

    //原始数据 00000000 00000000 00000000 10000000
    //强转后的数据: 10000000 (这是存在计算机内部的补码,反码是多少?


    byte b1 = (byte) 128;//强转编译通过,但损失精度
    System.out.print(b1); //-128

    short t = 32767;//编译通过
    short t = 32768;//编译报错
    char cc = 65535;//编译通过 (理论上 65535 int类型 4个字符,不能赋值给char 2个字符
    char Cc = 65536; //编译报错

    //当一个整数类型字面值没有超过byte short char的取值范围,允许直接int赋值给byte short char变量
    }

}

JAVA = 基于内裤开发(类库 
*javase 类库字节码

*javase 类库源码  G:\javaJDK\jdk-11.0.10\lib\src.zip

例如String.java和 String.class
(String []args)
5.3 浮点型 

float(单精度 4字节 
double(双精度 8字节


double (精度仍然不够 不能做财务等精度高软件
sun公司在基础类库中 准备了精确度更高的引用数据类型java.math.BigDecimal

*java中所有的浮点型字面值默认被作为double处理(末尾加 f 可以作为 float处理

    double d = 3.0; //编译通过
    
    float f = 3.0; //编译错误,默认3.0 为double
    float f = (float)3.0;
    float f = 3.0f;
 
//double 和 float 在计算机二进制存储时都是近似值(例如3.33333....无限循环 计算机存储空间有限 只能存近似值

5.4 布尔型 boolean  /ˈbuːliən/ 

只有 true 和 false ,占用一个字节

 true计算机底层是1 和 false底层是0

public class DataType{
    public  static void main(String []args)
    {
        
        boolean flag = 1; // 编译报错 类型不兼容

        boolean loginSuccess = true;

        if(loginSuccess)
        {
            System.out.println("成功");
        }else{
            System.out.println("失败");
            }
    }
}
        

5.5 数据类型转换
    *除boolean类型,其余七种数据类型都可以互相转换
        
    *小容量向大容量转换,成为自动类型转换

        byte <  short < int < long < float < double
            char
        //任何浮点类型不管占多少字节,都比整数型容量大
        char和short种类数量相同,但char可以去更大的正整数

    *大容量向小容量转换,称为强制类型转换,但可能损失精度
    *当一个整数类型字面值没有超过byte short char的取值范围,允许直接int赋值给byte short char变量
    *byte short char混合运算时,各自转成int在运算
    *多种数据类型运算,先转换成大容量数据类型在运算


                
public class DataTypeTest06 {
public static void main(String[] args) {

//出现错误,1000 超出了 byte 的范围
//byte a = 1000;
//正确,因为 20 没有超出 byte 范围
//所以赋值
byte a = 20;
//变量不能重名
//short a = 1000;
//正确,因为数值 1000 没有超出 short 类型的范围
//所以赋值正确
short b = 1000;
//正确,因为默认就是 int,并且没有超出 int 范围
int c = 1000;
//正确,可以自动转换
long d = c;
//错误,出现精度丢失问题,大类型-->>小类型会出现问题
//int e = d;
//将 long 强制转换成 int 类型
//因为值 1000,没有超出 int 范围,所以转换是正确的
int e = (int)d;
//因为 java 中的运算会会转成最大类型
//而 10 和 3 默认为 int,所以运算后的最大类型也是 int
//所以是正确的
int f = 10/3; // 3(int类型取整  double dd = 10/3;  //3.0(右边先算出int 3 再转成double  double d =10.0/3 //3.33333335(右边混合运算 先都转换成double 再算
//声明 10 为 long 类型
long g = 10;
//出现错误,多个数值在运算过程中,会转换成容量最大的类型
//以下示例最大的类型为 double,而 h 为 int,所以就会出现大类型(long)到小类
型(int)
//的转换,将会出现精度丢失问题
//int h = g/3;
//可以强制转换,因为运算结果没有超出 int 范围
//int h = (int)g/3;
//可以采用 long 类型来接收运算结果
//long h = g/3;
//出现精度损失问题,以下问题主要是优先级的问题
//将 g 转换成 int,然后又将 int 类型的 g 转换成 byte,最后 byte 类型的 g 和 3 运算,
那么
//它的运算结果类型就是 int,所以 int 赋值给 byte 就出现了精度损失问题
//byte h = (byte)(int)g/3;    //编译机只检查语法 
//正确
//byte h = (byte)(int)(g/3);   //括号优先级    
//不能转换,还有因为优先级的问题
//byte h = (byte)g/3;
//可以转换,因为运算结果没有超出 byte 范围
//byte h = (byte)(g/3);
//可以转换,因为运算结果没有超出 short 范围
short h = (short)(g/3);
short i = 10;
byte j = 5;
//错误,short 和 byte 运算,首先会转换成 int 再运算
//所以运算结果为 int,int 赋值给 short 就会出现精度丢失问题
//short k = i + j;
//可以将运算结果强制转换成 short
//short k = (short)(i + j);
//因为运算结果为 int,所以可以采用 int 类型接收
int k = i + j;
char l = 'a';
System.out.println(l);
//输出结果为 97,也就是 a 的 ascii 值
System.out.println((byte)l);
int m = l + 100;
//输出结构为 197,取得 a 的 ascii 码值,让后与 100 进行相加运算
System.out.println(m);
} }


编译机(只认语法 和运行机

5.6 运算符

算术运算符             +, -, *, /, ++, --, %(求余数

关系运算符            <, <=, >, >=,==, !=

布尔运算符(逻辑         &&, ||, &, |, !

位运算符            &, |, ~, ^, >>, >>>, <<
                & 按位与(AND)[真真为真,真假为假]
                | 按位或(OR)[假假为假,其余全真]
                ^ 按位异[相同为假,不同为真] ~按位非(NOT)[真则假,假则真]
                >> 右移 
                >>> 右移,左边空出的位以 0 填充
                << 左移 

赋值类运算符            =, +=, -=, *=, /=, %=

字符串连接运算符        +

条件运算符            ?:

其他运算符            instanceof, new


*算数运算符
    
    一个表达式有多个运算符,有优先级,但可以加小括号提升优先级

public class OperaorTest
{
    public static void main(String []args)
    {
        //关于++(单目运算符

        int k = 10;
        k++;
        ++k;
        
        //++出现在变量后
        int a = 100;
        int b = a++; // a =101, b=100

        //++出现在变量前
        int a = 100;
        int b = ++ a; // a =101, b=101

    }
}

    延申*    System.out.println(e)
    *println

    public void println(int x){
        synchronized (this){
        print(x);
        newLine();
        }
    }


    int e = 100;
    System.out.println(e++);//100  int x = e++; 先赋值 后运算
    System.out.println(e); //101  

    System.out.println(++e );//101  int x = ++e; 先赋值 后运算
    System.out.println(e);//101


*关系运算符

    = 是赋值运算符
    == 是关系运算符

    关系运算符的运算结果一定是 true/false


    比较变量中保存的值

*逻辑运算符
        
    &    逻辑与
    |    逻辑或
    !    逻辑非        单目运算符
    ^    逻辑异或    (两边的算子只要不一样 就是true

    &&    短路与
    ||    短路或
    
    //逻辑运算符要求两边算子都是布尔类型,最后结果也是布尔类型
    // 逻辑与和短路与  逻辑或和短路或 运算结果一致,  只是短路存在短路现象

public class OpeartorTest
{
    public static void main(String []args)

    {
        //逻辑与和短路与
        int x = 10;
        int y = 8;

        System.out.println( x < y & ++x < y );//false
        System.out.println(x);// 11


        System.out.println( x < y && ++x < y ); // 第一个表达式为false,整个表达式为false,
        System.out.println(x);// 10           后面的表达式也不会执行,这种现象被成为短路现象    
        

        *第一个表达式执行为true,使用短路或(即整个表达式肯定为ture 后面不用执行
        *第一个表达式执行为false,使用短路与(即整个表达式肯定为false 后面不用执行
    }
}


*赋值运算符

    基本运算符 =

    扩展的运算符 += -= *= /= %=

    运算符的优先级:先执行右边的运算,再赋值给左边的变量

    byte b =10;
    b = b + 5;//编译错误(编译器只检查语法 发现b+5是int类型
    b += 5;//等同于 b = (byte)(b + 5);

    byte z = 0;
    z += 128;//超出btye范围,但是等于 z = (byte)(z + 128) //-128 强转后损失精度

    结论:扩展赋值运算符不改变运算结果数据类型,底层采用的是强制类型转换        

*字符串连接运算符 “+”
    *加法运算求和  
    *字符串的连接运算

    // 数字+数字 = 数字 (求和
    // 数字+字符串 = 字符串    

    字符串拼接

*三元运算符/三目运算符/条件运算符 ?:
    
    *规则: 布尔表达式?表达式1:表达式2

        布尔表达式为true,表达式1为表达式结果
        布尔表达式为false,表达式2为表达式结果

    只是一个运算符 ,不是表达语句
        char c ? '男' : '女'
        char c ? “男” : '女' //编译报错 可能是String 也可能是char

        System.out.println(char c ? “男” : '女')//可以


6.控制语句
    *选择结构
      - if if..else
      - switch

    *循环结构
      - for
      - while
      - do..while()

    *控制循环的语句
      break
      continue


*if     分支语句/条件控制语句
    
    1.四种表达方式
    
第一种:
    if(布尔表达式){
        java语句
    }


第二种:
    if(布尔表达式){
        java语句
    }else{

    }

第三种:
    if(布尔表达式){
        java语句
    }else if(布尔表达式){

    }else if(布尔表达式){

    }else if(布尔表达式){

    }

第四种:if(布尔表达式){
        java语句
    }else if(布尔表达式){

    }else if(布尔表达式){

    }else if(布尔表达式){

    }else{
    
    }

*If.java

*
        Scanner in = new Scanner(System.in);

        int a = in.nextInt();  //   String a = in.next();  //方法除了第一个后面首字母必须大写 nextInt

        System.out.println("你的成绩为" + a);

*switch 
    选择结构 分支语句

    switch( int 或者 string类型的字面值或者变量){
        case int 或者 string类型的字面值或者变量 :
        java语句;
        ....;
        break;

        case int 或者 string类型的字面值或者变量 :
        java语句;
        ....;
        break;

        case int 或者 string类型的字面值或者变量 :
        java语句;
        ....;
        break;

        default:
        java语句;
        ....;                

    }
    
    //写break 匹配成功执行结束;不写 break 直接在下一个分支执行,执行至有break(case穿透现象

    btye short char 也可以写在switch后面 自动类型转换

public class Switch{
    public static void main(String []args){
        Scanner s = new Scanner(System.in);
        Scanner date = s.nextInt();
        Switch(date){
            case 1 :
                System.out.println("星期一");
                break;

            case 2 :
                System.out.println("星期二");
                break;
                                
            case 3 :
                System.out.println("星期三");
                break;
            case 4 :
                System.out.println("星期四");
                break;

            default:
                System.out.println("出错了");
                
                        
    }
}

*循环结构
    for while do..while


*for 循环
    for(初始化表达式;布尔表达式;更新表达式){
    
    }

for循环的执行过程/原理【*******】

public class ForTest{
    public static void main(String []args){
        for(int i =1;i <= 10;1++){
            System.out.println(i);
        }
    }
}

*while 循环
    while(布尔表达式){
        循环;
    }            //0-N次

*do..while

    do{
        循环体;
    }while(布尔表达式);  //1-N次 谨记最后的分号

*控制循环语句

*break 
        break; // 终止循环

    
    A:for ( int i = 1; i < 10; i++){
        B:for(int j =1; j<10; j++){
    
            if (i == 5){
            break A;
            }
        }

    }

*continue

//本循环停止,直接下一个循环


    for ( int i = 1; i < 10; i++){
        for(int j =1; j<10; j++){
            if (i == 5){
            continue;
            }
        System.out.println(i)  // 1 2 3 4 6 7 8 9
        }

    }