第二课-Java基础语法

当前位置:

首页 > 编程开发 > Java教程 >

第二课-Java基础语法

Java的注释

注释:对代码的解释,让人更容易了解代码,是给写代码的人看

// 单行注释

/*
多行注释
前面不一定非要加*号

*/

// java文档注释
/**
 * 文档注释,开头输入/**
 */

Java标识符和关键字

关键字:Java中已经被使用了的单词,通常表示一些关键概念或者定义或者特定用法
标识符:Java所有组成部分都需要名字.类名,变量名以及方法名都被成为标识符,标识符起名时我们需要遵守一些规范

Java的数据类型

强类型语言:要求变量的使用要严格符合规定,所有变量都必须先定义再使用.例如Staring a = 'hello',int num = 10
弱类型语言:跟强类型语言相对
Java是一种强类型语言

Java的两种数据类型

基本类型
- 数值类型
  - 整数类型
    - byte占1个字节范围
    - short占2个字节范围
    - int占4个字节范围
    - long占8个字节范围
  - 浮点类型
    - float占4个字节
    - double占8个字节
  - 字符类型
    - char占2个字节
- boolean类型:占一位且值只有true和false两种
引用类型:除了固定几种基本类型外,其余全是引用类型.例如类,接口,数组

int num1 = 10;  // 最常用
long num2 = 30L;  // Long类型要數字後面加L
        
float num3 = 50.1F;  // float類型要在數字后面加F
double num4 = 3.141592653;
        
// 字符,注意字符衹能有一個字
char name = 'A';
// 字符串,注意String不是關鍵字,也不是基本數據類型,是一個類
String namea = "你的名字";
        
// 布爾值
boolean flag = true;

计算机数据存储的一些基本知识

位(bit):是计算机内部数据存储的最小单位,11001100是一个八位二进制数
字节(byte):是计算机中数据处理的基本单位,习惯上用B表示
1B(byte,字节) = 8bit(位)
字符:是指计算机中使用的字母,数字,字和符号
电脑32位和64位与寻址能力直接挂钩,32位只能使用32位内存(最高4G),64位可以使用32位或者64位内存(最高128G)

数据类型拓展

public class Hello {
    public static void main(String[] args) {
        /* 整数拓展
        进制:
        1.二进制(0b开头)
        2.八进制(0开头)
        3.十进制

        4.十六进制(0x开头)
         */
        int i1 = 10;
        int i2 = 0b10;   // 二进制
        int i3 = 010;    // 八进制
        int i4 = 0x10;  // 十六进制

        System.out.println(i1);
        System.out.println(i2);
        System.out.println(i3);
        System.out.println(i4);
    }
}

public class Hello {
    public static void main(String[] args) {
        /* 浮点数拓展

        float,double:只能表示有限位的离散数(非完全精确),会存在舍入误差,只是一个大约值(接近但不等于)
        最好完全避免使用浮点数进行比较
        最好完全避免使用浮点数进行比较
        最好完全避免使用浮点数进行比较
         */
        float i1 = 0.1f;
        double i2 = 1.0/10;

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

        System.out.println("=====================");
        float d1 = 231313131313f;
        float d2 = d1 + 1;
        System.out.println(d1==d2);
    }
}

public class Hello {
    public static void main(String[] args) {
        /* 字符拓展
        所有字符本质上都是数字,所以有时可以将字符转换为数字,编码表将数字与字符一一对应
        例如:unicode编码中(97=a,65=A)
        转义字符\t 制表符;\n 换行符

         */
        char c1 = 'A';
        char c2 = '中';
        char c3 = '\u0061';  //a

        System.out.println(c1);
        System.out.println(c2);
        System.out.println(c3);
        System.out.println((int) c1);  //强制转换类型为int
        System.out.println((int) c2);
        System.out.println("hello\nworld");
        System.out.println("==========");
        String sa = new String("hello");
        String sb = new String("hello");
        System.out.println(sa==sb);  //不相等因为分配的内存地址不一样,从内存进行分析,new新建了内存
        String sc = "hello";
        String sd = "hello";
        System.out.println(sc==sd);  //未分配新内存地址,相等
    }
}

类型转换

由于java是强类型语言所以进行某些运算时,需要用到类型转换.
运算中,不同类型的数据需要先转换为同一类型再进行运算
强制类型转换,从高位转低位需要强制转换
自动类型转换:从低位到高位一般是自动转换

一般来说,低位转高位均可以,但高位转低位会出现问题

低------------------------------>高

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

public class Hello {
    public static void main(String[] args) {
        int i = 128;
        byte b = (byte) i;  //强制转换,内存溢出

        //强制转换  (类型)变量名  高位->低位需要强制转换

        System.out.println(i);
        System.out.println(b);  //byte范围为-128~127,所以内存溢出

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

         */

        System.out.println("============");
        System.out.println((int)23.7);
        System.out.println((int) -45.89);

        System.out.println("============");
        char c = 'a';
        int d = c + 1;
        System.out.println(d);
        System.out.println((char) d);
    }
}

public class Hello {
    public static void main(String[] args) {
        // 操作较大数字的时候注意内存溢出问题
        // JDK7开始,数字之间可以使用下划线分割
        // long类型后缀用大写的L
        int money = 10_0000_0000;
        int year = 20;
        long total = money * year;  //还是错的,原因运行顺序为先按int计算值->赋值给total->转换为long类型
        long total2 = money * ((long)year);

        System.out.println(total);
        System.out.println(total2);
    }
}

变量,常量,作用域

变量:可以变化的量,值可以改变
常量:初始化后就不能改变值,不会变动的值,程序运行过程中不允许改变
java是一种强类型语言,每个变量都必须声明类型
Java变量是程序中最基本的存储单元,其要素包括变量名,变量类型和作用域

type varName [=value] [{,varName[=value]}]

数据类型 变量名=值;可以使用逗号隔开来声明多个同类型变量

final 常量名=值;
常量名一般使用大写字母

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

public class Hello {
    //类变量 static,从属于当前类,会随当前类一起产生一起消失
    static double salary = 2500;
    //常量,修饰符之间不存在先后顺序
    static final double PI = 3.14;

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

    public static void main(String[] args) {
        //局部变量,必须声明和初始化值
        String name;
        int age;
        //变量类型 变量名字 = new Hello()
        Hello hello = new Hello();
        System.out.println(Hello.name);
        System.out.println(Hello.age);
        System.out.println(salary);
        System.out.println(PI);
    }
}

变量命名规范

所有变量,方法,类名:见名知意
类成员变量,局部变量,方法名:首字母小写和驼峰原则monthSalary
常量:大写字母和下划线MAX_VALUE
类名:首字母大写和驼峰原则:GoodMan

运算符

基本运算符

public class Hello {
    public static void main(String[] args) {
        //二元运算符,两个元素进行运算
        int a = 10;
        int b = 20;
        int c = 30;
        int d = 40;

        System.out.println(a + b);
        System.out.println(a - b);
        System.out.println(a * b);
        System.out.println(a / (double) b);  //注意要转换成对应类型,不然会出现舍入误差
    }
}

public class Hello {
    public static void main(String[] args) {
        long a = 12312121212121212L;
        int b = 123;
        short c = 10;
        byte d = 8;

        System.out.println(a + b + c + d);  //long
        System.out.println(b + c + d);  //int
        System.out.println(c + d);  //int,不管原来是什么类型,全部变成了int类型
    }
}

自增自减运算符

public class Hello {
    public static void main(String[] args) {
        int a = 3;
        int b = a++;  //执行逻辑为:执行完该行代码后,先把值赋给b,之后a再自增
        System.out.println(a);

        int c = ++a;  //执行逻辑为:执行完该行代码后,a先进行自增,之后再赋值给b

        System.out.println(b);
        System.out.println(c);
    }
}

逻辑运算符,位运算符

java写运算符的时候,不用刻意记住优先级,使用括号反而更加清晰.

public class Hello {
    public static void main(String[] args) {
        //短路运算,指在进行判断时,如果第一个条件为假可判断整句为假,则后面的都不执行
        int c = 5;
        boolean d = (c < 4) && (c++ < 4);  //因为c<4为假,所以后面的c++不执行
        System.out.println(d);
        System.out.println(c);  //因为短路运算,c++未执行,所以c仍为5
    }
}

public class Hello {
    public static void main(String[] args) {
        /* 位运算

        A = 0011 1100
        B = 0000 1101

        A&B = 0000 1100  //A,B相同位数都是1才等于1,否则为0
        A/B = 0011 1101  //A,B相同位数都是0才等于0,否则为1
        A^B = 0011 0001  //A,B相同位数值相同,该位为0,否则为1
        -B = 1111 0010  //跟B完全相反

        2*8使用位运算最快,跟底层打交道
        0000 0010 = 2
        0001 0000 = 16  二进制当中直接右移3位即可

         */
        System.out.println(2<<3);  //右移运算
    }
}

public class Hello {
    public static void main(String[] args) {
        //三元运算符,x?y:z
        //如果x==true,返回y,否则返回z
        int score = 80;
        String type = score < 60 ? "不及格" : "及格";
        System.out.println(type);
    }
}

包机制

为了更好地组织类,java提供了包机制,用于区别类名的命名空间.实际就是文件夹,相同名称的文件可以同时存在于不同的文件夹中.
包语句的语法格式为
```
package pkg1 [. pkg2[. pkg3...]]
```
一般使用公司域名倒置作为包名,例如com->baidu->baike作为各级包的命名

为了使用某一个包的成员,我们需要在java中明确导入该包

import pkg1 [.pkg2...].(classname|*)  //*代表导入该包下所有的类

JavaDoc

javadoc命令是用来生成自己的API文档的

命令行输入

javadoc -encoding UTF-8 -charset UTF-8 Doc.java

出　　处：https://www.cnblogs.com/hanxueyan/p/14614472.html

栏目列表