基础语法

 

 

注释、标识符、关键字

 

注释（解释说明）

//注释（解释说明）
        /*
            单行注释://
            多行注释:/*  注释  */
            文档注释:/**
            *@Descruption HelloWorld
            *@Author hzyjava学习
            */
        */

注释不会被执行，只是给我们人看的

书写注释是一个非常好的习惯

标识符（类名、变量名以及方法名都被称为标识符）

标识符注意点
//
        /*
        1. 所有的标识符都应该以字母（**A-Z或者a-z**），美元符（**￥**）、或者**下划线（_）**开始
        2. 首字符之后可以是字母(A-Z或者a-z),   美元符号 （￥）、下划线（_）或**数字的任何字符组合**
        3.  **不能使用关键字**作为变量名或方法名
        4.  标识符是**大小写敏感的**
        5.  合法标识符举例：age、￥salary、_value、__value
        6. 非法标识符举例：123abc、-salary、#abc
        */
//正确的标识符:
        String abc="hzy";
        String abc="hzy";
        String _Abc="hzy";
        String $abc="hzy";
//错误的标识符:
        String 1abc="hzy";
        String #abc="hzy";
        String a#bc="hzy";

关键字

学习篇——计算机_JavaSe_基础语法_运算符

 

 

数据类型

 

数据类型分类：

强类型语言（Java，C++）

要求变量的使用要严格符合规定，所有变量都必须先定义后才能使用（安全性高，速度慢）

弱类型语言（JS）

位、字节、KB、MB、G...字符

//位、字节、KB、MB、G...字符
        /*
        •   **位（bit）:是计算机内部数据存储最小单位,11001100是一个八位二进制数**
​
        •   **字节（byte）:是计算机中数据处理的基本单位,习惯上用大写B来表示**
​
        •   **1B（byte,字节)= 8bit(位)**
​
        •   **字符:是指计算机中使用的字母、数字、字和符号**
​
​
​
        1bit表示1位
​
        1Byte表示一个字节 1B-8b。
​
        1024B=1KB
​
        1024KB=1M
        1021M=1G
​
        1024G=1TB
        */
        //电脑的32位和64位的区别是什么呢？（寻址能力）64位可支持128G内存，32可支持4GB内存

Java的数据类型分两大类

基本类型（primitive type）
//基本类型（primitive type）
        /*
        数值类型:
            整数类型:
                byte占1个字节范围:-128-127
                short占2个字节范围:-32768-32767
                int占4个字节范围:-2147483648-2147483647
                long占8个字节范围:-9223372036854775808-9223372036854775807
            浮点类型:
                float占4个字节
                double占8个字节
            字符类型：
                char占2字节
        boolean类型:
                占1位其值只有true和false两个
          */
八大基本数据类型(byte、short、int、long、float、double、char、boolean)
//八大基本数据类型(byte、short、int、long、float、double、char、boolean)
        //整数
        byte num1=10;
        short num2=10;
        int num3=10;//最常用
        long num4=30L;//long类型要在数字后面加个L
​
        //s小数：浮点数
        float num5=50.1F;//float类型要在数字后面加个F
        double num6=3.14159265358979323846263;
​
        //字符
        char name ='A';
        //字符串，String不是关键字，类
        String namea ="hzy";
​
        //布尔值:是非
        boolean flag =true;
        boolean flag =false;
引用类型（reference type）
//引用类型（reference type）
        //类
        //接口
        //数组

扩展

整数扩展
//整数拓展?
//进制     二进制0b    十进制    八进制0    十六进制0x
​
        int i =10;
        int i2 =010;  //八进制0;
        int i3 =0x10; //十六进制0x   0~9  A~F
​
        //输出                    输出结果
        System.out.println(i);//10
        System.out.println(i2);//8
        System.out.println(i3);//16
​
浮点数扩展
//浮点数扩展？  
//银行业务怎么表示?钱
        //BigDecimal    数学工具类
        //float   //有限  离散  舍入误差  大约  接近但不等于
        //double
        //最好完全避免使用浮点数进行比较
        //最好完全避免使用浮点数进行比较
        //最好完全避免使用浮点数进行比较
        float f=0.1f;//0.1
        double d=1.0/10;//0.1
        
        //输出                    输出结果
        System.out.println(f==d);//false
        float d1=231313132315316164f;
        float d2=d1+1;
        //输出                    输出结果
        System.out.println(d1==d2);//true
字符扩展
//字符拓展？
        char c1 ='a';
        char c2 ='中';
        System.out.println(c1);
        System.out.println((int)c1);//强制换行
        System.out.println(c2);
        System.out.println((int)c2);//强制换行
​
        //所有的字符本质还是数字
        //编码  Unicode  表:(97=a  65=A )2字节   早期0 - 65536  Excel :2的16次方 = 65536
        //U0000  UFFFF
        char c3 ='\u0061';
        System.out.println(c3);
​
        //转义字符
        //\t  制表符
        //\n  换行
        //...
        System.out.println("hello\nword");
​
        String sa =new String("hello world");
        String sb =new String("hello world");
        //输出                    输出结果
        System.out.println(sa==sb);//true
        String sc = "hello world";
        String sd = "hello world";
        //输出                    输出结果
        System.out.println(sc==sd);//false
        //对象 从内存分析
​
布尔值扩展
//布尔值扩展?
        bololean flag = true ;
        if (flag==true){}//新手
        if(flag){} //老手
        //Less is More!     代码要精简易读
​

 

 

类型转换

 

由于Java是强类型语言，所以要进行有些运算的时候的，需要用到类型转换。

低 ---------------------------------------->高
byte,short，char->int->long->float->double（小数优先级大于整数）

运算中，不同类型的数据先转化为同一类型，然后进行运算。

强制类型转换、自动类型转换

//强制转换      （类型）变量名   高- - 低
//自动转换      低- - 高
​
        int i=128;
        byte b=(byte)i;//内存溢出
        
        //输出                    输出结果
        System.out.println(i);//128
        System.out.println(b);//-128        内存溢出
        System.out.println((int)-45.89f);//45       精度问题
​
        char c ='a';
        int d =c+1;
​
        //输出                    输出结果
        System.out.println(d);//98
        System.out.println((char)d);//d
        /*
        注意点:
        1.不能对布尔值进行转换(布尔是按照位的，这是完全不相干的)
        2.不能把对象类型转换为不相干的类型
        3.在把高容量转化为低容量的时候，强制转换
        4.转换的时候可能存在内存溢出，或者精度问题！
         */

解决强制类型转换、自动类型转换出现的问题

//操作比较大的数的时候，注意溢出问题
        //JDK7新特性 ， 数字之间可以用下划线分割
        int money =10_0000_0000;
        int years = 20;
        int total = money*years;//-1474836480 , 计算的时候溢出了
        long total2 = money*years;//默认是int，转换之前已经存在问题了?
​
        long total123 = money*((long)years);
        //输出                    输出结果
        System.out.println(total);//-1474836480
        System.out.println(total2);//-1474836480
        System.out.println(total123);//200_0000_0000
​
        //尽量用L  小写l经常会被看成1

 

 

变量、常量

 

变量：可以变化的量 常量：初始化(initialize)后不能再改变值!不会变动的值

Java是一种强类型语言，每个变量都必须声明其类型。

Java变量是程序中最基本的存储单元，其中包括变量名，变量类型和作用域

type varName [=value] [{,varName[=value]}]  ; 
    //数据类型   变量名 = 值；
    //可以使用逗号隔开来声明多个同类型变量。（不建议）
     //int a,b,c;
     //int a=1,b=2,c=3;  //不建议，程序可读性很差
     String name = "hzy";
     char x='X';
     double pi =3.14;

变量作用域（类变量、实例变量、局部变量）

public class Variable{
    static int allClicks=0;     //类变量
    String str="hello world";   //实例变量
    
    public void method(){
        int i = 0;  //局部变量
    }
}
//类变量 static
        static double salary = 2500;
​
        //属性；变量
​
//实例变量；从属对象；如果不进行初始化，这个类型的默认值
        //布尔值:默认是false
        //除了基本类型，其余的默认值都是null；
        String name;
        int age;
​
        //main方法
        public static void main(String[] args) {
​
//局部变量；必须声明和初始化值
        int i= 10;
        System.out.println(i);
​
        //变量类型  变量名字 = new DataType04();
        DataType04 dataType04 = new DataType04();
        //输出                    输出结果
        System.out.println(dataType04.age);//0
        System.out.println(dataType04.name);//null
​
        //类变量 static
        //输出                    输出结果
        System.out.println(salary);//2500
    }
​
    //其他方法
    public  void add(){
​
    }

注意事项

        1.每个变量都有类型，类型可以是基本类型，也可以是引用类型。
        2.变量名必须是        "合法的标识符
        3.变量声明是一条完整的语句，因此每一个声明都必须以  "分号"    结束

变量的命名规范

所有变量、方法、类名：见名知意

类成员 变量:首字母小写和驼峰原则:monthSalary 除了第一个单词以外， 后面的单词首字母大写 lastname lastName

局部 变量:首字母小写和驼峰原则

常量:大写字母和下滑线:MAX_VALUE

类名：首字母大写和驼峰原则:Man,GoodMan

方法名:首字母小写和驼峰原则：run(),runRun()

所谓常量可以理解成一种特殊的变量，它的值被设定后，在程序运行过程中不允许被改变。

final 常量名=值;
final double PI=3.14;

常量名一般使用大写字符。

//修饰符，不存在先后顺序
        static final double PI=3.14;
​
        //final static int i=10;
        public static void main(String[] args) {
            System.out.println(PI);

 

 

运算符

 

Java 语言支持如下运算符：

  • 算数运算符:+, -, *, /, %, ++, --

  • 赋值运算符：=

  • 关系运算符：>, <, >=, <=, ==, != instanceof

  • 逻辑运算符：&&, ||, !

  • 位运算符：&, |, ^, ~, >>, <<, >>>(了解！！！)

  • 条件运算符：? :

  • 扩展赋值运算符：+=, -=, *=, /=

算数运算符
//二元运算符
        //Ctrl + D : 复制当前行到下一行
        int a = 10;
        int b = 20;
        int c = 25;
        int d = 25;
​
        //输出                    输出结果
        System.out.println(a+b);//30
        System.out.println(a-b);//-10
        System.out.println(a*b);//200
        System.out.println(a/(double) b);//0.5
不同基本类型运算 后的 输出结果类型
        long a = 123123123123123L;
        int b = 123;
        short c = 10;
        byte d = 8;
        double e =1.1;
        
//不同基本类型运算  后的  输出结果类型
        //输出                    输出结果类型
        System.out.println(a+e);//double
        System.out.println(a+b+c+d);//Long
        System.out.println(b+c+d);//Int
        System.out.println(c+d);//Int
关系运算符返回的结果
//关系运算符返回的结果:   正确，错误   布尔值
        //      真/1/true        假/0/false
        //if
​
        int a = 10 ;
        int b = 20 ;
        int c = 21 ;
​
        //取余，模运算
        System.out.println(c%a);//c/a   21/10   = 2...1
​
        //输出                    输出结果
        System.out.println(a>b);//false
        System.out.println(a<b);//true
        System.out.println(a==b);//false
        System.out.println(a!=b);//true
自增、自减、幂运算运算
//自增运算：     ++      一元运算符
//自减运算：     --      一元运算符
        int a = 3;
​
        int b = a++;//执行完这行代码后，先给b赋值，再自增
        //a++  a = a+1
        System.out.println(a);
        int c = ++a;//执行完这行代码后，先自增，再给b赋值
        //a++  a = a+1
​
        //输出                    输出结果
        System.out.println(a);//4
        System.out.println(b);//3
        System.out.println(c);//5
​
        //幂运算:      2^3   2*2*2   =8
        double pow = Math.pow(2,3);
        //输出                    输出结果
        System.out.println(pow);//16
逻辑运算
//逻辑运算：     与（and）     或(or)   非(取反)
        boolean a =true;
        boolean b =false;
        
        System.out.println("a&&b:"+(a&&b));//逻辑与运算:两个变量都为真，结果才为真
        System.out.println("a||b:"+(a||b));//逻辑或运算:两个变量有一个为真，则结果才为真
        System.out.println("!(a&&b):"+!(a&&b));//如果是真，则变为假，如果是假，则变为真
​
//短路运算：     
        int c = 5;
        boolean d = (c<4)&&(c++<4);//       c<4已经可以判断结果,没有必要执行后面的判断
        //输出                    输出结果
        System.out.println(d);//false
        System.out.println(c);//5
        d = (c>4)&&(c++<4);
        //输出                    输出结果
        System.out.println(c);//6
位运算
//位运算：
//<<(左移)        *2
//>>(右移)        /2 
        /*
        A= 0011 1100
        B= 0000 1101
​
        A&B =   0000 1100  //与：对应位    均为1则为1，有0则为0
        A|B =   0011 1101   //或：对应位   均为0则为0，其余都是1
        A^B =   0011 0001   //异或：对应位   相同为0，不同为1
        ~B = 1111 0010  //非
​
        2*8 =16   2*2*2*2
        (位运算)效率极高!!!
        <<(左移)      *2
        >>(右移)      /2
​
        0000 0000   0
        0000 0001   1
        0000 0010   2
        0000 0011   3
        0000 0100   4
        0000 1000   8
        0001 0000   16
​
         */
        //输出                    输出结果
        System.out.println(2<<3);//16       向左移动三位
偷懒、字符串连接
//偷懒：       +=,-=,*=,/+
        int a = 10;
        int b = 20;
​
        a+=b;//a = a+b;
        a-=b;//a = a-b;
​
        System.out.println(a);
​
//字符串连接符：       +   ,Sting
        //输出                    输出结果
        System.out.println(a+b);//30
        System.out.println(""+a+b);//1020
        System.out.println(a+b+"");//30
三元运算符
//三元运算符：        x ? y : z
//如果x==true，则结果为y，否则结果为z
​
        int score = 80;
        //int score = 50;
        String type = score <60?"不及格":"及格";
        //if
        //输出                    输出结果
        System.out.println(type);//及格
优先级

 

 

包机制、JavaDo'c

 

为了更好的组织类，Java提供了包机制，用于区别类名的命名空间

包语句的语法格式为：

package pkj1[. pkj2[. pkg3]];

一般利用公司域名倒置作为包名

为了能够使用某一个包的成员，我们需要再Java程序中明确导入该包。使用"import"语句可完成此功能

import package1[.package2...].(classname|*);