java02-基础语法

数据类型：

DK中类型对应的包装类都帮忙写好了，我们需要时候可
以直接看到！可以把以下代码拷贝进行查看结果：

public class NewGame {
    public static void main(String[] args) {
        System.out.println(Byte.SIZE);
        System.out.println(Byte.MAX_VALUE);
        System.out.println(Byte.MIN_VALUE);
        System.out.println(Integer.SIZE);
        System.out.println(Integer.MAX_VALUE);
        System.out.println(Integer.MIN_VALUE);
    }
    }

位（bit）：是计算机 内部数据 储存的最小单位，11001100是一个八位二进制数。 字节（byte）：
是计算机中 数据处理 的基本单位，习惯上用大写 B 来表示, 1B（byte,字节）= 8bit（位） 字符：
是指计算机中使用的字母、数字、字和符号 ASCIIS码：
1个英文字母（不分大小写）= 1个字节的空间
1个中文汉字 = 2个字节的空间 1个ASCII码 = 一个字节 UTF-8编码：
1个英文字符 = 1个字节 英文标点 = 1个字节 1个中文（含繁体） = 3个字节
中文标点 = 3个字节 Unicode编码：
1个英文字符 = 2个字节
英文标点 = 2个字节 1个中文（含繁体） = 2个字节

浮点类型float, double的数据不适合在不容许舍入误差的金融计算领域。
如果需要进行不产生舍入误差的精确数字计算，需要使用BigDecimal类。

public class NewGame {
    public static void main(String[] args) {
        float a= 0.1F;
        double b= 0.1;
        System.out.println(a+" "+b);  
        if(a==b){
            System.out.println("ture");
        }
        else
        {System.out.println("false");}
    }

}
//        结果:
//        0.1 0.1
//        false

字符类型可以表示单个字符,字符类型是 char，char 是两个字节(可以存放汉字)，多个字符我们用字符串 String:

public class NewGame {
    public static void main(String[] args) {
        char a = 'A';
        System.out.println(a);
        System.out.println((int)a);
        String b="A";
        System.out.println(b);
    }
}
//        A:
//        65
//        A

注意“A”和’a’ 的不同

自动类型转换

由于Java是强类型语言，所以要进行有些运算的时候的，需要用到类型转换。
整型、实型（常量）、字符型数据可以混合运算。
运算中，不同类型的数据先转化为同一类型，然后进行运算。
转换从低级到高级（根据容量来看）

低 ------------------------------------> 高
byte,short,char—> int —>long—> float —> double

数据类型转换必须满足如下规则：
不能对boolean类型进行类型转换。
不能把对象类型转换成不相关类的对象。
在把容量大的类型转换为容量小的类型时必须使用强制类型转换。
转换过程中可能导致溢出或损失精度

自动类型转换：容量小的数据类型可以自动转换为容量大的数据类型。

public class NewGame {
    public static void main(String[] args) {
        char a = 'A';
        System.out.println(a+5);
    }
}
//       输出 70

强制类型转换

强制类型转换，又被称为造型，用于显式的转换一个数值的类型.
在有可能丢失信息的情况下进行的转换是通过造型来完成的，但可能造成精度降低或溢出。
强制类型转换的语法格式： (type)var ，运算符“()”中的type表示将值var想要转换成的目标数据类
型。 条件是转换的数据类型必须是兼容的。

public class NewGame {
    public static void main(String[] args) {
        int a=65;
        System.out.println((char)a);
    }
}
//       输出 A

变量，常量

public class NewGame {
    public static void main(String[] args) {
        int a=1,b=2,c=3;
        float d=4;
        double abc=4.1;
        byte e='A';
        String s="abc";
    }
}

【编码规范】
虽然可以在一行声明多个变量，但是不提倡这个风格，逐一声明每一个变量可以提高程序可读性。

变量作用域

变量根据作用域可划分为三种：
类变量（静态变量： static variable）：独立于方法之外的变量，用 static 修饰。
实例变量（成员变量：member variable）：独立于方法之外的变量，不过没有 static 修饰。
局部变量（lacal variable）：类的方法中的变量。

public class NewGame {
    static int b= 0;  //类变量，静态变量
    int a=5;  //实例变量(成员变量)
    public void test(){
        int c=0;//局部变量
    }
}
//       输出 A

局部变量

方法或语句块内部定义的变量。生命周期是从声明位置开始到”}”为止。
在使用前必须先声明和初始化(赋初值)。
局部变量没有默认值，所以局部变量被声明后，必须经过初始化，才可以使用。

实例变量

方法外部、类的内部定义的变量。
从属于对象，生命周期伴随对象始终。
如果不自行初始化，他会自动初始化成该类型的默认初始值
（数值型变量初始化成0或0.0，字符型变量的初始化值是16位的0，布尔型默认是false）

静态变量

使用static定义。
从属于类，生命周期伴随类始终，从类加载到卸载。
如果不自行初始化，他会自动初始化成该类型的默认初始值
（数值型变量初始化成0或0.0，字符型变量的初始化值是16位的0，布尔型默认是false）

常量

常量(Constant)：初始化(initialize)后不能再改变值！不会变动的值。
所谓常量可以理解成一种特殊的变量，它的值被设定后，在程序运行过程中不允许被改变。

final double PI=3.14; final String L=“你好”;

变量的命名规范

1. 所有变量、方法、类名：见名知意
2. 类成员变量：首字母小写和驼峰原则 : monthSalary
3. 局部变量：首字母小写和驼峰原则
4. 常量：大写字母和下划线：MAX_VALUE
5. 类名：首字母大写和驼峰原则: Man, GoodMan
6. 方法名：首字母小写和驼峰原则: run(), runRun()

运算符

Java 语言支持如下运算符：
算术运算符: +，-，，/，%，++，–
赋值运算符 =
关系运算符: >，<，>=，<=，==，!= instanceof
逻辑运算符: &&，||，!
位运算符: &，|，^，~ ， >>，<<，>>> (了解！！！)
条件运算符 ？：
扩展赋值运算符:+=，-=，=，/=

逻辑运算符

逻辑与和逻辑或采用短路的方式。从左到右计算，如果确定值则不会再计算下去。在两个操作数都为
true时，结果才为true，但是当得到第一个操作为false时，其结果就必定是false，这时候就不会再判断
第二个操作了。
逻辑与只要有一个为false, 则直接返回false.
逻辑或只要有一个为true, 则直接返回true;

位运算符

public class NewGame {
    public static void main(String[] args) {
        System.out.println(2<<3);// 输出 16  0010 变成1000
        System.out.println(1<<3);// 输出 4   0001 变成1000
    }
}

扩展运算符

字符串连接符

“+” 运算符两侧的操作数中只要有一个是字符串(String)类型，系统会自动将另一个操作数转换为字符串
然后再进行连接。

public class NewGame {
    public static void main(String[] args) {
        int a=1;
        String c="abc";
        System.out.println(c+a); //输出abc1
    }
}

三目条件运算符

x ? y : z
其中x为boolean类型表达式，先计算x的值，若为true，则整个三目运算的结果为表达式y的值，否则整
个运算结果为表达式z的值。

public class NewGame {
    public static void main(String[] args) {
        int a=1;
        int b=2;
        int c=a>b?1:0;
        System.out.println(c); //输出0
    }
}

运算符优先级

包机制

存在这样一个问题：当定义了多个类的时候，可能会发生类名的重复问题。
解决方式：在java中采用包机制处理开发者定义的类名冲突问题。
就好比我们平时的用电脑，一个文件夹下不能存在同名的文件，我们要是有这样的需求，但是又不想换
名字，我们就可以考虑使用新建一个文件夹来存放！在我们的Java中也是这样的。

包的作用：
1、把功能相似或相关的类或接口组织在同一个包中，方便类的查找和使用。
2、如同文件夹一样，包也采用了树形目录的存储方式。同一个包中的类名字是不同的，不同的包中的类
的名字是可以相同的，当同时调用两个不同包中相同类名的类时，应该加上包名加以区别。因此，包可
以避免名字冲突。
3、包也限定了访问权限，拥有包访问权限的类才能访问某个包中的类。
Java 使用包（package）这种机制是为了防止命名冲突，访问控制，提供搜索和定位类（class）、接
口、枚举（enumerations）和注释（annotation）等。
包语句的语法格式为：
创建包的时候，你需要为这个包取一个合适的名字。之后，如果其他的一个源文件包含了这个包提供的
类、接口、枚举或者注释类型的时候，都必须将这个包的声明放在这个源文件的开头。
包声明应该在源文件的第一行，每个源文件只能有一个包声明，这个文件中的每个类型都应用于它。
如果一个源文件中没有使用包声明，那么其中的类，函数，枚举，注释等将被放在一个无名的包
（unnamed package）中。
一般利用公司域名倒置作为报名；

import 关键字

为了能够使用某一个包的成员，我们需要在 Java 程序中明确导入该包。使用 “import” 语句可完成此功
能。
在 java 源文件中 import 语句应位于 package 语句之后，所有类的定义之前，可以没有，也可以有多
条，其语法格式为

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

用 import 关键字引入，使用通配符 "" , 导入io包下的所有类！
**import java.io.;**