Java基础

标识符

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

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

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

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

• 标识符是大小写敏感的

• 合法标识符举例：fuck、$abcd、_abcd、__1_abcd

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

数据类型

强类型语言

• 要求变量的使用要严格符合规定，所有变量都必须先定义后才能使用（强类型语言包括Java、.net 、Python、C++等语言）

弱类型语言

• 弱类型语言是一种弱类型定义的语言，某一个变量被定义类型，该变量可以根据环境变化自动进行转换，不需要经过显性强制转换（弱类型语言包括vb 、PHP、javascript等语言）

Java的数据类型分为两大类

基本数据类型

基本数据类型只有8种，可按照如下分类
①整数类型：long、int、short、byte
②浮点类型：float、double
③字符类型：char
④布尔类型：boolean

引用数据类型

引用数据类型非常多，大致包括：类、 接口类型、 数组类型、 枚举类型、 注解类型、 字符串型

什么是字节

• 位(bit):是计算机内部数据储存的最小单位，11001100是一个八位二进制数
• 字节(byte):是计算机中数据处理的基本单位，习惯上用大写B来表示
• 1B (byte,字节)= 8bit(位)
• 字符:是指计算机中使用的字母、数字、字和符号

类型转换

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

1.低转高的数据类型，可以自动转换

例：

public static void main(String[] args) {
        short i = 128;
        int j  = i;
        System.out.println(j);//输出128
    }

2.如果由高的数据类型转换到低的数据类型的话，则需要强制转换

例：

public static void main(String[] args) {
        long a = 12800;
        int b  = (int)a;
        System.out.println(b);//输出12800
    }

注意点：

1.不能对布尔值进行转换

2.不能把对象类型转换为不相干的类型

3.把高容量转换到低容量的数据类型时，需要强制转换

4.转换的时候可能存在内存溢出，或者精度缺失的问题

例：

public static void main(String[] args) {
        //操作比较大的数时，要注意溢出问题
        //JDK7新特性，数字可以用下划线进行分割
        int money = 10_0000_0000;
        int year = 20;
        int total =  money*year;
        System.out.println(total);//输出-1474836480,是由于计算的时候溢出了
    
        long total2 = money*year;
        System.out.println(total2);//也是输出-1474836480,因为转换之前就已经溢出
    
        long tatal3 = money*((long)year);//正确写法应该是先把一个数转换为long，再进行计算
        System.out.println(tatal3);//输出20000000000
    }

变量、常量、作用域

变量

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

type varName = value 
//数据类型 变量名 = 值; 也可以用逗号隔开来声明多个变量

注意事项:

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

public static void main(String[] args) {
	int a=1,b=2,c=3;//为了程序可读性，不建议一行创建多个变量
    String name = "张三";
    int age = 47;
    char sex = ‘男‘;
}

变量作用域

变量是有作用范围（Scope）的，也即作用域。一旦超出变量的作用域，就无法再使用这个变量。在程序中，变量一定会被定义在某一对大括号中，该大括号所包含的代码区便是这个变量的作用域。

1.局部变量

在一个方法或方法内代码块中定义的变量称为局部变量，局部变量在方法或代码块被执行时创建，在方法或代码块结束时被销毁。局部变量在进行取值前必须被初始化，否则会编译错误。

2.实例变量

public class Test {
    //实例变量：从属于对象，可以不初始化值，如果不自行初始化值，则会是默认值
    String name;
    int age;
    boolean flag;
    double a;
    float b;

    public static void main(String[] args) {
        Test test = new Test();
        System.out.println(test.name);//输出null
        System.out.println(test.age);//输出0
        System.out.println(test.flag);//输出false
        System.out.println(test.a);//输出0.0
        System.out.println(test.b);//输出0.0
        //布尔值的默认值是false，基本类型的默认值是0或0.0，其余的默认值都是null
    }
}

3.类变量

类变量是随着类的加载而加载的，和实例变量的区别是类变量不需要实例化

public class Test {
    static int age = 18;//类变量

    public static void main(String[] args) {
        System.out.println(age);//输出18，不需要实例化可以直接输出
    }
}

常量

• 常量(Constant):初始化(initialize)后不能再改变值!不会变动的值。
• 所谓常量可以理解成一种特殊的变量，它的值被设定后，在程序运行过程中不允许被改变。
• 常量名一般使用大写字符。

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

public class Test {

    static final double PI = 3.14;

    public static void main(String[] args) {
        System.out.println(PI);//正常可输出3.14
        
        final int A = 15000;
        A = 16000;//会报错，因为A已经被final定义为常量，所以不允许改变
    }
}

变量的命名规范

• 所有变量、方法、类名:见名知意
• 类成员变量:首字母小写和驼峰原则:myAge
• 局部变量:首字母小写和驼峰原则:myName
• 常量:大写字母和下划线:MAX_VALUE
• 类名:首字母大写和驼峰原则: Man,GoodMan
• 方法名:首字母小写和驼峰原则: run(), runRun()

//类名
public class GoodMan {
    //常量名
    static final double MAX_VALUE = 30000;
    //类成员变量
    int myAge = 17;
    public static void main(String[] args) {
        //局部变量
        String myName = "张三";
    }
    //方法名
    public void runRun(){}
}

运算符

Java语言支持如下运算符：

• 算术运算符：+，-，*，/，%，++，--
• 赋值运算符：=
• 关系运算符：>，<，>=，<=，==，!=，instanceof
• 逻辑运算符：&&，||，!
• 位运算符：&，|，^，~，>>，<<，>>>
• 条件运算符：? :
• 扩展运算符：+=，-=，*=，/=

基本运算符的注意点

例1：使用算术运算符时要考虑数据类型的转换，以免出现精度缺失

public static void main(String[] args) {
        int a = 10;
        int b = 20;
        System.out.println(a+b);//输出30
        System.out.println(a-b);//输出-10
        System.out.println(a*b);//输出200
        System.out.println(a/b);//输出0，正确得数应该是0.5，由于int是整数，所以小数点后的数被去掉了
        System.out.println(a/(double)b);//输出0.5,a除以b可以进行强转来得出正确得数
    }

例2：数据类型的隐式转换

public static void main(String[] args) {
        long a = 123456789123L;
        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类型
        //在整数类型中，如果相加数有long类型,则会转换为long
        //在整数类型中，没有long类型，则所有非int型会转换为int类型
    }

自增自减运算符

例：++a和a++的区别（自减同理）

public static void main(String[] args) {
        int a = 3;
        System.out.println(a);//输出3，此时a并未自增
        int b = a++;//a++是把a=3赋值给了b再进行自增
        int c = ++a;//++a是自增之后再赋值给了c，由于前面int b = a++的时候，a赋值之后已经自增了，所以等于5
        System.out.println(a);//输出5
        System.out.println(b);//输出3
        System.out.println(c);//输出5
    }

逻辑运算符

例：逻辑运算符的与或非

public static void main(String[] args) {
        //逻辑运算符： 与&&  或||  非!
        boolean a = true;
        boolean b = false;
        System.out.println("a && b:"+(a&&b));//输出为false，两个变量为真，结果才为true
        System.out.println("a || b:"+(a||b));//输出为true,只要一个变量为真，结果为true
        System.out.println("a && b:"+!(a&&b));//输出true，如果a&&b的结果为真，加上非则为假，反之亦然
    }

例：短路运算，&&具有短路功能，即第一个表达式为false则不会再计算第二表达式

public static void main(String[] args) {
        //短路运算：&&具有短路功能，即如果第一个表达式为false则不会再计算第二表达式
        int a = 5;
        boolean b = (a < 4)&&(++a < 4);
        System.out.println(b);//输出false
        System.out.println(a);//输出5，由此可见第二表达式的++a并没有自增

        //但是单个&也可以当作逻辑运算符，但它则不会造成短路运算
        int c = 5;
        boolean d = (c < 4)&(++c < 4);
        System.out.println(c);//输出6
    }

位运算符

与&，或|，非~，异或^

位运算符主要针对二进制，逢二进一
A = 0011 1100
B = 0000 1101
-------------------------------------
A&B则是A与B的每位进行比较，可以把0当作false，1当作true进行比较，两个数的位都为1则为1
其中有一个0则为0
A&B = 0000 1100
-------------------------------------
A|B则是如果两位比较都是0则为0，否则为1
A|B = 0011 1101
-------------------------------------
A^B = 0011 0001 异或是比较两个操作数的位中，相同的数则结果为0，不同则结果为1
-------------------------------------
~B = 1111 0010  取反则是每位中0则为1，1则为0

<<左移 >>右移

public static void main(String[] args) {
    /* 二进制换算
        0 = 0000 0000
        1 = 0000 0001
        2 = 0000 0010
        3 = 0000 0011
        4 = 0000 0100
        8 = 0000 1000
       16 = 0001 0000
     */
    //左移<<相当于*2，右移>>相当于/2
    System.out.println(2<<3);//输出16，在二进制中则是把1左移3位
}

扩展运算符

例：a+=b即是a=a+b，a-=b则是a=a-b，以此类推

public static void main(String[] args) {
        int a = 10;
        int b = 20;
        a+=b;//a+=b相当于a=a+b，-=,*=,/=亦是如此
        System.out.println(a);//输出30
}

条件运算符 : ?

例: x ? y : n 的意思是如果x的结果为true，则结果为左边y，否则结果为右边n

public static void main(String[] args) {
        int score = 80;
        //如果score大于60的结果是true则返回冒号左边的值，否则返回右边，赋值给type
        String type = score > 60 ? "合格" : "不合格";
        System.out.println(type);//输出合格
    }

Java基础

原文：https://www.cnblogs.com/TriggerBlog/p/14957000.html