Java的基础语法

Java基础语法

 

注释

  • 平时我们编写代码,在代码量比较少的时候,我们还可以看懂自己写的,但是当机构框架一旦复杂起来,我们就需要用到注释了。

  • 注释你并不会被执行,是给我们写代码的人看的

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

  • 平时写代码一定要注意规范

 

  • Java中的注释有三种:

    • 单行注释

    • 多行注释

    • 文档注释

 

标识符

  • 关键字

 

  • Java所有的组成部分都需要名字。类名、变量名以及方法名都被成为标识符。

 

标识符注意点

  • 所有的标识符都应该以字母(A-Z或者a-z),美元符($)、或者下划线(_)开始

  • 首字符之后可以是字母(A-Z或者a-z),美元符($)、下划线(_)或者数字的任何字符组合

  • 不能使用关键字作为变量名或方法名

  • 标识符是大小写敏感

  • 合法标识符举例:age、$salary、_value、__1_value

  • 非法标识符举例:123abc、-salary、#abc

 

public static void main (String[]args){
   String 王者荣耀 = "最强王者";
   System.out.println(王者荣耀);
}

 

  • 可以使用中文命名,但是一般不建议这样去使用,也不建议使用拼音,很 low

 

数据类型

  • 强类型语言

    • 要求变量的使用要严格符合规定,所有变量都必须先定义后才能使用

  • 弱类型语言

 

  • Java的数据类型分为两大类

    • 基本类型(primitive type)

    public static void main(String[] args) {

       //八大基本数据类型

       //整数
       int a = 10; //常用
       byte b = 20;
       short c = 30;
       long d = 30L;   //long类型要在数字后面加个L

       //小数:浮点数
       float e = 2.1F; //float类型要在数字后面加个F
       double f = 1.22;

       //字符
       char name = '铭';
       //字符串,String不是关键字,是类
       //String name1 = "崔力铭";

       //布尔值:是非
       boolean gd = true;
       //boolean gd = false;

    }
    public static void main(String[] args) {
       //整数扩展:     进制     二进制0b   十进制   八进制0 十六进制0x

       int i = 10;
       int i1 = 010;   //八进制前面加0
       int i2 = 0x10;  //十六进制前面加0x

       System.out.println(i);
       System.out.println(i1);
       System.out.println(i2);
       System.out.println("=================================================================");

       //=================================================================
       //浮点数扩展?   银行业务怎么表示?钱
       //BigDecimal   数字工具类
       //=================================================================
       //float     有限 离散     舍入误差   大约 接近但不等于
       //double
       //最后得出:最好完全避免使用浮点型进行比较
       //最后得出:最好完全避免使用浮点型进行比较
       //最后得出:最好完全避免使用浮点型进行比较



       float f = 0.1f;     //0.1
       double d = 1.0/10;  //0.1

       System.out.println(f==d);   //false
       // System.out.println(f);
       // System.out.println(d);

       float d1 = 12361534156123f;
       float d2 = d1 + 1;

       System.out.println(d1==d2); //true

       System.out.println("=================================================================");

       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
       // Unicode:U0000开始     UFFFF结束

       char c3 = '\u0061';

       System.out.println(c3); //a

       System.out.println("=================================================================");

       //转义字符
       // \t 制表符
       // \n 换行
       // .....

       System.out.println("Hello\tWorld");
       System.out.println("Hello\nWorld");
       System.out.println("Hello\rWorld");

       System.out.println("=================================================================");

       String  sa = new String("hello world");
       String  sb = new String("hello world");
       System.out.println(sa==sb);

       String sc = "hello world";
       String sd = "hello world";
       System.out.println(sc==sd);
       //对象   从内存分析

       //布尔值扩展
       boolean falg = true;
       if(falg==true){}    //新手
       if(falg){}          //老手

       //less is More!     代码要精简易读
    }
    • 引用类型(reference type)

 

 

 

什么是字节

  • 位(bit)是计算机内部数据 储存的最小单位,11001100是一个八位二进制数。

  • 字节(byte):是计算机中数据处理的基本处理,习惯上用大写B来表示

  • 1 B(byte,字节)= 8 bit(位)

  • 字符:是指计算机中使用的字母、数字、字和符号

 

  • 1 bit表示1位

  • 1 byte表示一个字节 1 B = 8 b。

  • 1024 B = 1 KB

  • 1024 KB = 1 M

  • 1024 M = 1 G

 

类型转换

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

   ------------------------------------------> 

byte,short,zhar -> int -> long ->float -> double
   

注意:上面小数的优先级永远大于整数。

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

  • 强制类型转换

  • 自动类型转换

 public static void main(String[] args) {
       int i = 128;
       byte b = (byte)i;

       System.out.println(i);
       System.out.println(b);  //内存溢出
       //强制转换 (类型)变量名     高 ~ 低
//---------------------------------------------------------------------------------------
       int p = 111;
       double d = p;

       System.out.println(p);
       System.out.println(d);
       //自动转换   低 ~ 高

       /*
       注意点:
       1. 不能对布尔类型进行转换
       2. 不能把对象类型转换为不想干的类型
       3. 在把高容量转换到低容量的时候,强制转换
       4. 转换的时候可能存在内存溢出,或者精度问题!
        */

       //强制转换高容量到低容量会存在精度问题
       System.out.println("======================================");
       System.out.println((int)13.14);
       System.out.println((int)5.21F);

       //类型转换
       System.out.println("======================================");
       char c = 'a';
       int f = c+1;
       System.out.println(f);
       System.out.println((char) f);
  }
public static void main(String[] args) {
   //操作比较大的数的时候,注意溢出问题
   //JDK7新特性,数字之间可以用下划线分割
   int money = 10_0000_0000;
   int years = 20;
   int total = money*years;    // -1474836480,计算时溢出了
   long total2 = money*years;  //默认是int,转换之前已经存在问题了

   long total3 = money*((long)years);  //把一个数强转换为long
   System.out.println(total);  //溢出
   System.out.println(total2); //溢出
   System.out.println(total3); //正确


}

 

 

变量

  • 变量是什么:就是可以变化的量!

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

  • Java变量是程序中最基本的储存单位,其要素包括变量名,变量类型和作用域

type varName [=value][{,varName[=value]}];
//数据类型 变量名 = 值;可以使用逗号隔开来声明多个同类型变量。
  • 注意事项:

    • 每个变量都有类型,类型可以是基本类型,也可以是引用类型。

    • 变量名必须是合法的标识符。

    • 变量声明是一条完整的语句,因此每一个声明都必须以分号结束。

    //举一些变量的例子
    public static void main(String[] args) {
       //int a,b,c;
       //int a = 1,b = 2,c = 3;   //程序可读性
       String name = "yueyue";
       char x = 'X';
       double c= 12.12;

    }

变量作用域

  • 类变量

  • 实例变量

  • 局部变量

    //类变量   static
   static double salary = 2500;


   //属性:变量
//实例变量:从属于对象;如果不自行初始化,这个类型的默认值 0 0.0
   //布尔值:默认是false
   //除了基本类型,其余的默认值都是null;
   String name;
   int age;

   //main方法
   public static void main(String[] args) {

       //局部变量;必须声明和初始化值
       int i = 10;
       System.out.println(i);

       //变量类型 变量名称 = new Demo07();
       Demo07 demo07 = new Demo07();
       System.out.println(demo07.age);
       System.out.println(demo07.name);

       //类变量   static
       System.out.println(salary);
  }

 

 

常量

  • 常量(Constant):初始化(initialize)后不能在改变值!不会变动的值。

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

final   常量名 = 
final double PI = 3.14;
  • 常量名一般使用大些字符。

 

变量的命名规范

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

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

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

  • 常量:大写字母和下划线:MAX_VALUE

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

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

 

修饰符

// static、final这两个是修饰符,不存在先后顺序,谁在前都行。
static final double CUI = 5.21;

public static void main(String[] args) {

   System.out.println(CUI);
}

 

运算符

  • Java语言支持如下运算符:

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

    public static void main(String[] args) {

    //二元运算符
    //Ctrl + D :复制当前行到下一行
    int a = 5;
    int b = 20;
    int c = 25;
    int d = 30;

    System.out.println(a+b);
    System.out.println(b-a);
    System.out.println(c*b);
    //如果除的结果是小数,用int就会出错,所以除/就要使用强转double
    System.out.println(d/(double)a);

    }
    public static void main(String[] args) {
    long a = 12343513236L;
    int b = 1234;
    short c = 123;
    byte d = 12;

    //cast(转换)
    //如果计算中有long类型就是long类型,没有long类型就都默认为Int类型。
    System.out.println(a+b+c+d); //Long
    System.out.println(b+c+d); //Int
    System.out.println(c+d); //Int
    }
    public static void main(String[] args) {

    //一元运算符
    //++ 自增 -- 自减

    int a = 3;

    int b = a++; //执行完这行代码后,先给b赋值,在让a自增。
    //a = a + 1
    System.out.println(a);
    //a = a + 1
    int c = ++a; //执行完这行代码前,先让a自增,再给c赋值。

    System.out.println(a);
    System.out.println(b);
    System.out.println(c);
    System.out.println("==============================================");


    int i = 3;

    int d = i--; //执行完这行代码后,先给d赋值,后让i自减。
    //i = i - 1;
    System.out.println(i);
    //i = i - 1;
    int e = --i; //执行完这行代码前,先让i自减,后给e赋值。

    System.out.println(d);
    System.out.println(e);
    System.out.println("==========================================");

    //幂运算 2^3 2*2*2 = 8 很多运算,我们会使用一些工具来操作!
    double pow = Math.pow(3,2); //3的2次方
    double pow1 = Math.pow(2,3); //2的3次方
    System.out.println(pow);
    System.out.println(pow1);
    }
    • 赋值运算符:=

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

    public static void main(String[] args) {

    //关系运算符返回的结果:正确,错误 用布尔值进行比较
    //if

    int a = 10;
    int b = 20;
    int c = 21;

    //关系运算符计算:
    System.out.println(a<b);
    System.out.println(a>b);
    System.out.println(a==b);
    System.out.println(a<=b);
    System.out.println(a>=b);
    System.out.println(a!=b);

    //取余,也叫做模运算。
    System.out.println(c%a); //==c/a 21/10 取余数

    }
    • 逻辑运算符:&&,||,!

    //逻辑运算符
    public class Demo05{
    public static void main(String[] args) {
    // 与(and) 或(or) 非(取反)
    boolean a = true;
    boolean b = false;

    System.out.println("a && b :" + (a&&b)); //逻辑与运算:两个变量都为真,结果为真;有一个变量为假一个为真,则结果为假。
    System.out.println("a || b :" + (a||b)); //逻辑或运算:两个变量都为假,结果为假;有一个变量为真一个为假,则结果为真。

    //如果是真(true),则变为假(false);如果是假(false),则变为真(true)。[与(and)和 或(or)都会执行取反]
    System.out.println("! (a && b) :" + ! (a&&b));
    System.out.println("! (a || b) :" + ! (a||b));
    System.out.println("========================================================");

    //短路运算
    int c = 5;
    boolean d = c < 4 && c++>4;
    System.out.println(d);
    System.out.println(c);
    }
    • 位运算符:&,|,^,~,>>,<<,>>>(了解!!!)

    位逻辑运算符:
    &:
    位与运算符,只有两个操作数都是true,结果才是true。
    | :
    位或运算符,只有两个操作数都是false,结果才是false。
    ~:
    位非运算符:如果位为0,结果是1,如果位为1,结果是0.
    ^:
    位异或运算:两个数转为二进制,然后从高位开始比较,如果相同则为0,不相同则为1。

    位同或运算:两个数转为二进制,然后从高位开始比较,如果相同则为1,不相同则为0。java中并没有同或运算符,可以通过异或转换得到。同或运算 = 异或运算 ^ 1

    逻辑运算符:
    &&:
    逻辑与运算,也是只有两个操作数都是true,结果才是true。但是如果左边操作数为false,就不计算右边的表达式,直接得出false。类似于短路了右边。
    ||:
    逻辑或运算,也是只有两个操作数都是false,结果才是false。但是如果左边操作数为true,就不计算右边的表达式,直接得出true。类似于短路了右边。
    !:
    逻辑非运算,对操作数取反。
    //位运算
    public class Demo06 {
       public static void main(String[] args) {

           /*
           A = 0011 1100
           B = 0000 1101
    ----------------------------------------------------------
           A&B = 0000 1100     A位与B(A&B):两方位数都是1才为1,其他都为0。
           A|B = 0011 1101     A位或B(A|B):两方位数有一个是1就为1,两个都是0才为0。
           A^B = 0011 0001     A位异B(A^B):两个位数相同为0,两个位数不相同则为1。
           =============================
           位非(~A   ~B):取反,是1则为0;是0则为1
           ~A = 1100 0011
           ~B = 1111 0010

           -=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-
           2*8 = 16   2*2*2*2
           位运算效率极高!!!
           <<(左移)*乘
           >>(右移)/除

           0000 0000   0
           0000 0001   1
           0000 0010   2
           0000 0011   3
           0000 0100   4
           0000 0101   5
           0000 0111   6
           0000 1000   7
           0000 1001   8
           0000 1011   9
           0000 1111   10
           0001 0000   11
           0001 0001   12
           0001 0010   13
           0001 0011   14
           0001 0100   15
           0001 0101   16
            */


      }
    • 条件运算符?:

    //三元运算符
    public static void main(String[] args) {

       //x ? y : z
       //如果x==true 那结果就为y,否则就为z

       int score = 75;
       int score1 = 59;
       //必须掌握!!!
       String type = score>=60 ? "及格" : "不及格";
       String tybe = score1>=60 ? "及格" : "不及格";
       System.out.println(score);
       System.out.println(type);
       System.out.println(tybe);
    }
    • 扩展赋值运算符:+=,-=,*=,/=

    //扩展赋值运算符
    public static void main(String[] args) {

       int a = 10;
       int b = 20;

       a+=b;   //a = a + b
       a-=b;   //a = a - b
       System.out.println(a);
       System.out.println(b);

       //字符串连接符   +
       System.out.println(a+b);
       System.out.println(""+a+b); //如果输出计算中出现String类型,它就会把计算中的加法转换为连接符。
       System.out.println(a+b+""); //可当计算在前String类型在后面时,会先执行计算再连接字符。
    }
    •    

posted @ 2021-06-02 20:46  编程新锐__铭  阅读(339)  评论(0)    收藏  举报