Day002 Java基础语法

Java基础语法

标识符

所有标识符以大小写字母(a_z，AZ)，美元符号($)，下划线(_)开头

正确命名：

String Ahello  = "jdl"; //大小写敏感
String ahello  = "jdl";
String $hello  = "jdl";
String _hello  = "jdl";

错误命名：

String 1hello  = "jdl";
String #hello  = "jdl";
String *hello  = "jdl";

不建议用中文，拼音命名

用英文命名更容易阅读

String name = "jdl";
String mignzi = "jdl";
String 名字 = "jdl";

数据类型

八大基本类型

btyte 占1个字节范围：-128~127

short 占2个字节范围：-32768~32767

int 占4个字节范围：-2147483648~2147483647

long 占8个字节范围：-9223372036854775808~9223372036854775807

float 占4个字节范围：1.4E-45~3.4028235E38

double 占8个字节范围：4.9E-324~1.7976931348623157E308

char 占2个字节

blooean 占1个字节

//整数类型
byte num2 = 20;
short num3 = 30;
int num1 = 10;  //最常用
long num4 = 40L;    //Long类型要在数字后面加个L

//小数类型：浮点数
float num5 = 50.1F; //Long类型要在数字后面加个F
double num6 = 3.1415926;

//字符类型
char name1 = '杰';
//字符串，String不是关键字，是类
String name2 = "杰达鲁";

//布尔值：是，非
boolean flag1 = true;
boolean flag2 = false;

整数拓展：进制转换

int i1 = 0b10;  //二进制0b
int i2 = 10;    //十进制
int i3 = 010;   //八进制0
int i4 = 0x10;  //十六进制0x 0~9 A~F

浮点数拓展：浮点数精度有限，最好完全避免使用浮点数进行比较

float f = 0.1f;      		//0.1
double d = 1.0 / 10;  		//0.1
System.out.println(f == d); //false

float d1 = 23333333333333333333f;
float d2 = d1 + 1;
System.out.println(d1 == d2);//true

字符拓展：所有的字符本质还是数字

char c1 = 'a';
char c2 = '中';
char c3 = 'u0061';

System.out.println(c1);		 //a
System.out.println((int) c1);//97

System.out.println(c2);		 //中
System.out.println((int) c2);//20013

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

类型转换

运算中，不同类型的数据先转换成同一类型，再进行运算

低-------------------------------------------------------->高 (浮点数的优先级高于整数)

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

int i = 128;
byte b = (byte) i;   	//内存溢出
double d = i;

//强制转换  (类型)变量名     高->低
System.out.println(b);	//-128

//自动转换  低->高
System.out.println(d);	//128.0

注意点：

不能对布尔值进行转换
不能把对象类型转换为不相干的类型
在把高容量转换到低容量的时候，强制转换
转换的时候可能存在内存溢出，或者精度问题！

System.out.println((int) 23.7);    //23
System.out.println((int) -45.89f); //-45

char c = 'a';
int c1 = c + 1;
System.out.println(c1);			//98
System.out.println((char) c1);	//b

//操作比较大的数的时候，注意溢出问题
//JDK7新特性，数字之间可以用下划线分割
int money = 10_0000_0000;
System.out.println(money);		//1000000000

int years = 20;
int total = money * years;
System.out.println(total);  	//-1474836480，计算的时候溢出了

long total1 = money * years;
System.out.println(total1); 	//-1474836480，total1默认int，转换成long之前就已经存在问题了

long total2 = money * ((long)years);
System.out.println(total2);		//20000000000

变量

tpye varName [=value] [{,varName[=value]}];
//数据类型 变量名 = 值;	可以使用逗号隔开声明多个同类型变量

不建议在一行声明多个变量

int a, b,c; 	//不建议这样写

//建议分行设置变量
int a = 1;
int b = 2;
int c = 3;
String name = "jiedalu";
char x = 'X';
double pi = 3.14;

变量作用域

类里除了能定义方法，还能定义属性(变量)
从属于对象，如果不自行初始化，这个类型的默认值为0或0.0
布尔值：默认是false
除了基本类型，其余的默认值都是null

public class Demo06 {

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

    //实例变量
    String name;
    int age;

    //main方法
    public static void main(String[] args) {
        //局部变量：必须声明和初始化值
        int i = 10;
        System.out.println(i);			//10

        //实例变量
        //变量类型 变量名字 = new demo08()
        Demo06 demo06 = new Demo06();
        System.out.println(demo06.age);	//0
        System.out.println(demo06.name);//nnull

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

    //其他方法
    public void add() {
        System.out.println();
    }
}

常量

常量是初始化后不能修改不能变化的值
常量名一般用大写字符

public class demo07 {

    //修饰符不区分先后顺序
    static final double PI = 3.14;

    public static void main(String[] args) {
        System.out.println(PI);	//3.14
    }
}

命名规范

类变量：首字母小写，驼峰原则，如：monthSalary，lastName
局部变量：首字母小写，驼峰原则
常量：大写字母，下划线如：MAX_VALUE
类名：首字母大写，驼峰原则
方法名：首字母小写，驼峰原则。如：run()，runRun()

基本运算符

二元运算符

+，-，*，/

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/(double)b);//0.5

>，<，==，!=，%

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

System.out.println(a>b); //false
System.out.println(a<b); //true
System.out.println(a==b);//false
System.out.println(a!=b);//true

//取余，模运算
System.out.println(c%a); //c%a  21/20=2...1

一元运算符

++，--

int a = 3;
int b = a++; //执行这段代码后，先给b赋值，再自增
/*  相当于
	b = a;
    a = a + 1;
*/

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

int c = ++a; //执行这段代码前，先自增，再给c赋值
/*  相当于
	a = a + 1;
	c = a;
*/

System.out.println(a);	//5
System.out.println(b);	//3
System.out.println(c);	//5

三元运算符

? :

x ? y : z
如果x==true，则结果为y，否则结果为z

int score = 80;
String type = score < 60 ? "不及格" : "及格";
System.out.println(type);//及格

逻辑运算符

&& 逻辑与运算：两个变量都为真，结果才true
|| 逻辑或运算，两个变量有一个为真，则结果才为true
! 如果是真，则变为假，如果是假，则变为真

boolean a = true;
boolean b = false;

System.out.println(b && a);	  //false
System.out.println(a || b);	  //true
System.out.println(!(a && b));//true

//短路运算: 与运算时，如果前面为假，则不运算后面的代码
int c = 5;
boolean d = (c<4)&&(c++<4);
System.out.println(d);	//false
System.out.println(c);	//5

位运算

位运算效率极高
&，|，^，~

A = 0011 1100
B = 0000 1101

A&B=0000 1100 A和B都是1则为1，否则为0
A|B=0011 1101 A或B是1则为1，否则为0
A^B=0011 0001 A和B相同为0，不同为1
~B =1111 0010 若是1则变为0，若是0则变为1

<<左移 *2
>>右移 /2

System.out.println(2<<3);//16

0000 0000   0
0000 0001   1
0000 0010   2	//把1左移三位
0000 0011   3
0000 0100   4
0000 1000   8
0001 0000   16	//变成16

扩展赋值运算符

+=，-=

a+=b; //a = a + b
a-=b; //a = a - b

字符串连接符 +

在+号任意一侧若出现了字符串类型(String)，则会把其他操作数都转换成String，再进行连接

int a = 10;
int b = 20;
System.out.println(a+b+""+a+b); //301020
System.out.println(""+a+b);		//1020

包机制

包机制用于区别类名的命名空间

package pkg1[. pkg2[. pkg3[...]]]

一般用公司域名倒置作为包名：com.mooncell.www
想要使用包中的成员，需要导入该包，使用"import"语句可完成这个功能

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

JavaDoc生成文档

package com.mooncell.base;

/**
 * @author Jiedalu
 * @version 0.1
 * @since 1.8
 */
public class Doc {

    String name;

    /**
     * @author Jiedalu
     * @param name
     * @return
     * @throws Exception
     */
    public String test(String name) throws Exception {
        return name;
    }
}

从文件夹打开命令行
输入javadoc -encoding UTF-8 -charset UTF-8 Doc.java

javadoc 生成文档

-encoding UTF-8 让编码变为UTF-8格式(用于显示更多中文，减少乱码)

-charset UTF-8 让字符集变为UTF-8格式(用于显示更多中文，减少乱码)
打开index.html