Java基础语法

注释

Java中注释有三种：

单行注释
多行注释
文档注释

标识符

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

关键字

表示类名的标识符用大写字母开始。
- 如：Man, GoodMan

表示方法和变量的标识符用小写字母开始，后面的描述性词以大写开始。
- 如：eat(),eatFood()
  - //驼峰命名法

关于 Java 标识符，有以下几点需要注意：

所有的标识符都应该以字母（A-Z 或者 a-z）,美元符（$）、或者下划线（_）开始
首字符之后可以是字母（A-Z 或者 a-z）,美元符（$）、下划线（_）或数字的任何字符组合
不能使用关键字作为变量名或方法名。
标识符是大小写敏感的
合法标识符举例：age、$salary、_value、__1_value
非法标识符举例：123abc、-salary、#abc
可以使用中文命名，但是一般不建议这样去使用，也不建议使用拼音，很Low。

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

数据类型

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

1、强弱类型语言

强类型语言也称为强类型定义语言。要求变量的使用要严格符合规定，所有变量都必须先定义后才能使用。

弱类型语言也称为弱类型定义语言。与强类型定义相反。像vb，php等就属于弱类型语言

2、数据类型

Java数据类型分为两大类：

基本类型（primitive type）
引用类型（reference type）
- 【注：引用数据类型的大小统一为4个字节，记录的是其引用对象的地址！】

public class Demo02 {public static void main(String[] args) {//整数byte num1 = 10;//短整型short num2 = 20;//整型 —— 最常用int num3 = 30;//长整型//long类型要在数字后面加Llong num4 = 30L;//浮点数//float类型要在数字后面加Ffloat num5 = 1.2F;//单精度double num6 = 3.1415926;//双精度//字符//单字符char name = 'A';//字符串，String不是关键字，是类//String name2 = "wang jin";//布尔值:是非boolean flag1 = true;boolean flag2 = false;}
}

Java语言的整型常数默认为int型，浮点数默认是Double

位（bit）：是计算机内部数据储存的最小单位，11001100是一个八位二进制数。
字节（byte）：是计算机中数据处理的基本单位，习惯上用大写 B 来表示。
- 1B（byte,字节）= 8bit（位）

字符：是指计算机中使用的字母、数字、字和符号
- 1bit表示1位，1Byte表示一个字节 1B=8b。1024B=1KB1024KB=1M1024M=1G.
ASCIIS码：1个英文字母（不分大小写）= 1个字节的空间1个中文汉字 = 2个字节的空间1个ASCII码 = 一个字节
UTF-8编码：1个英文字符 = 1个字节英文标点 = 1个字节1个中文（含繁体） = 3个字节中文标点 = 3个字节
Unicode编码：1个英文字符 = 2个字节英文标点 = 2个字节1个中文（含繁体） = 2个字节中文标点 = 2个字节
32位操作系统只可以使用32位的cpu，而64位的CPU既可以安装32位操作系统也可以安装64位操作系统。
寻址能力简单点说就是支持的内存大小能力，64位系统最多可以支达128 GB的内存，而32位系统最多只可以支持4G内存。
32位操作系统只可以安装使用32位架构设计的软件，而64位的CPU既可以安装使用32位软件也可以安装使用64位软件。

3、整数拓展

计算机中存在很多进制问题：二进制、十进制、八进制、十六进制

二进制数，以0b开头。
十进制整数，如：99, -500, 0。
八进制整数，要求以 0 开头，如：015。
十六进制数，要求 0x 或 0X 开头，如：0x15 。

4、浮点数拓展

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

public static void main(String[] args) {float f = 0.1f;double d = 1.0/10;System.out.println(f==d); //falsefloat d1 = 2313131212323342f;float d2 = d1 + 1;System.out.println(d1==d2); //true
}

主要理由：由于字长有限，浮点数能够精确表示的数是有限的，因而也是离散的。浮点数一般都存在舍入误差，很多数字无法精确表示，其结果只能是接近，但不等于；二进制浮点数不能精确的表示0.1、0.01、0.001这样10的负次幂。并不是所有的小数都能可以精确的用二进制浮点数表示。

最好完全避免使用浮点数比较 !
大数值：Java.math下面的两个有用的类：BigInteger和BigDecimal，这两个类可以处理任意长度的数值。BigInteger实现了任意精度的整数运算。BigDecimal实现了任意精度的浮点运算。

浮点数使用总结：

默认是double
浮点数存在舍入误差，很多数字不能精确表示。如果需要进行不产生舍入误差的精确数字计算，需要使用BigDecimal类。
避免比较中使用浮点数

5、字符拓展

单引号用来表示字符常量。

例如：‘A’是一个字符，它与“A”是不同的，“A”表示一个字符串。

char 类型用来表示在Unicode编码表中的字符。

所以的字符本质还是数字。

【代码演示：字符转int看结果】

public static void main(String[] args) {char c1 = 'a';char c2 = '中';System.out.println(c1);//强制转换System.out.println((int) c1); //97System.out.println(c2);//强制转换System.out.println((int) c2); //20013
}

Unicode编码被设计用来处理各种语言的所有文字，它占2个字节，可允许有65536个字符。Unicode具有从0到65535之间的编码，通常用从’u0000’到’uFFFF’之间的十六进制值来表示（前缀为u表示Unicode）

char c3 = '\u0061';
System.out.println(c3); //a

Java 语言中还允许使用转义字符 ‘’ 来将其后的字符转变为其它的含义，有如下常用转义字符：

6、布尔值拓展

boolean类型（一位，不是一个字节），就是0|1
boolean类型有两个值，true和false,不可以 0 或非 0 的整数替代 true 和 false ，这点和C语言不同。
boolean 类型用来判断逻辑条件，一般用于程序流程控制。

boolean flag = false;
if(flag){// true分支
}else{// false分支
}

【编码规范：很多新手程序员喜欢这样写】

if (is == true && un == false ) {...}

只有新手才那么写。对于一个熟练的人来说，应该用如下方式来表示：

if ( is && !un ) {....}

要习惯去掉所有的==fasle 和 ==true。

Less is More！代码要精简易读！

类型转换

强制类型转换
自动类型转换

Java是强类型语言，所以进行有些运算的时候，需要类型转换。整型、实型（常量）、字符型数据可以混合运算。

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

转换从低级到高级（根据容量来看）。

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

数据类型转换必须满足如下规则：

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

int i =128;
byte b = (byte)i;//内存溢出//因为byte类型是8位，最大值为127，所以当int强制转换为byte类型时，值128就会导致溢出。

浮点数到整数的转换是通过舍弃小数得到，而不是四舍五入，例如：

(int)23.7 == 23;
(int)-45.89f == -45

1、自动类型转换

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

例如: short数据类型的位数为16位，可以自动转换位数为32的int类型，同样float数据类型的位数为32，可以自动转换为64位的double类型。

public class ZiDongLeiZhuan{public static void main(String[] args){char c1='a';//定义一个char类型int i1 = c1;//char自动类型转换为intSystem.out.println("char自动类型转换为int后的值等于"+i1);char c2 = 'A';//定义一个char类型int i2 = c2+1;//char 类型和 int 类型计算System.out.println("char类型和int计算后的值等于"+i2);}
}

2、强制类型转换

强制类型转换，又被称为造型，用于显式的转换一个数值的类型。

在有可能丢失信息的情况下进行的转换是通过造型来完成的，但可能造成精度降低或溢出。

强制类型转换的语法格式：(type)var ，运算符“()”中的type表示将值var想要转换成的目标数据类型。条件是转换的数据类型必须是兼容的。

public static void main(String[] args) {double x = 3.14;int nx = (int)x; //值为3char c = 'a';int d = c+1;System.out.println(d); //98System.out.println((char)d); //b
}

当将一种类型强制转换成另一种类型，而又超出了目标类型的表示范围，就会被截断成为一个完全不同的值，溢出。

public static void main(String[] args) {int x = 300;byte bx = (byte)x; //值为44System.out.println(bx);
}

3、常见错误和问题

操作比较大的数时，要留意是否溢出，尤其是整数操作时；

public static void main(String[] args) {int money = 1000000000; //10亿int years = 20;int total = money*years; //返回的是负数long total1 = money*years; //返回的仍然是负数。默认是int，因此结果会转成int值，再转成long。但是已经发生了数据丢失long total2 = money*((long)years); //先将一个因子变成long，整个表达式发生提升。全部用long来计算。System.out.println(total);System.out.println(total1);System.out.println(total2);
}

L和l 的问题
- 不要命名名字为l的变量
  - long类型使用大写L不要用小写。

public static void main(String[] args) {int l = 2;long a = 23451l;System.out.println(l+1); //3System.out.println(a); //23451
}

4、JDK7拓展

JDK7新特性: 二进制整数

由于我们在开发中经常使用二进制整数，因此JDK7为我们直接提供了二进制整数的类型：只要 以 0b 开头 即可。

int a = 0b0101;

JDK7新特性：下划线分隔符

对于特别长的数字，JDK7为我们提供了下划线分隔符，可以按照自己的习惯进行分割。

int b = 1_2234_5678;
public static void main(String[] args) {int a = 0b0101;int b = 1_2345_7893;System.out.println(a); //5System.out.println(b); //123457893
}

变量常量

1、变量（variable）

Java是一种强类型语言，每个变量都必须声明其类型。
Java变量是程序中最基本的存储单元，其要素包括变量名、变量类型和作用域。
变量在使用前必须对其声明, 只有在变量声明以后，才能为其分配相应长度的存储单元，声明格式为：

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

注意事项：

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

【演示】

int a, b, c; // 声明三个int型整数：a、 b、c
int d = 3, e = 4, f = 5; // 声明三个整数并赋予初值
byte z = 22; // 声明并初始化 z
String s = "runoob"; // 声明并初始化字符串 s
double pi = 3.14159; // 声明了双精度浮点型变量 pi
char x = 'x'; // 声明变量 x 的值是字符 'x'。

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

2、变量作用域

变量根据作用域可划分为三种：

类变量（静态变量： static variable）：独立于方法之外的变量，用 static 修饰。
实例变量（成员变量：member variable）：独立于方法之外的变量，不过没有 static 修饰。
局部变量（lacal variable）：类的方法中的变量。

public class Variable{static int allClicks=0; // 类变量String str="hello world"; // 实例变量public void method(){int i =0; // 局部变量}
}

局部变量

方法或语句块内部定义的变量。生命周期是从声明位置开始到”}”为止。

在使用前必须先声明和初始化(赋初值)。

局部变量没有默认值，所以局部变量被声明后，必须经过初始化，才可以使用。

public static void main(String[] args) {int i;int j = i+5 ; // 编译出错，变量i还未被初始化System.out.println(j);
}
修改为：
public static void main(String[] args) {int i=10;int j = i+5 ;System.out.println(j);
}

实例变量

方法外部、类的内部定义的变量。从属于对象，生命周期伴随对象始终。

如果不自行初始化，他会自动初始化成该类型的默认初始值。

（数值型变量初始化成0或0.0，字符型变量的初始化值是16位的0，布尔型默认是false）

public class Test {// 这个实例变量对子类可见public String name;// 私有变量，仅在该类可见private double salary;...
}

静态变量

使用static定义。从属于类，生命周期伴随类始终，从类加载到卸载。

如果不自行初始化，它会自动初始化成该类型的默认初始值。

（数值型变量初始化成0或0.0，字符型变量的初始化值是16位的0，布尔型默认是false）

public class Employee {//salary是静态的私有变量private static double salary;// DEPARTMENT是一个常量public static final String DEPARTMENT = "开发人员";public static void main(String[] args){salary = 10000;System.out.println(DEPARTMENT+"平均工资:"+salary);}
}

3、常量

常量(Constant)：初始化(initialize)后不能再改变值。

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

final 常量名=值;
final double PI=3.14; final String LOVE="hello";

常量名一般使用大写字符。
程序中使用常量可以提高代码的可维护性。

4、变量的命名规范

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

运算符

运算符operator

Java 语言支持如下运算符：

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

1、二元运算符

整数运算

如果两个操作数有一个为Long, 则结果也为long
没有long时，结果为int。即使操作数全为shot、byte，结果也是int.

public static void main(String[] args) {long a = 1231321311231231L;int b = 1213;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类型
}

浮点运算

如果两个操作数有一个为double, 则结果为double.只有两个操作数都是float, 则结果才为float.

public static void main(String[] args) {float a = 3.14565F;double b = 3.194546464;float c = 1.3123123F;System.out.println(a+b); //double类型System.out.println(b+c); //double类型System.out.println(a+c); //float类型
}

关系运算符

返回布尔值

2、取模运算

其操作数可以为浮点数,一般使用整数。如：5.9%3.9=2.000000004

要点：

负数%负数＝负数；
负数%正数＝负数；
正数%负数＝正数；

public static void main(String[] args) {System.out.println(9 % 4); //1System.out.println(-9 % -4); //-1System.out.println(-10 % 4); //-2System.out.println(9 % -4); //1
}

3、一元运算符

自增（++）自减（--）运算符是一种特殊的算术运算符，在算术运算符中需要两个操作数来进行运算，而自增自减运算符是一个操作数，分为前缀和后缀两种。

public static void main(String[] args) {int a = 3;int b = a++; //执行完后,b=3。先给b赋值，再自增。int c = ++a; //执行完后,c=5。先自增,再给b赋值
}
//注意：java中的乘幂处理
public static void main(String[] args) {int a = 3^2; //java中不能这么处理， ^是异或符号。double b = Math.pow(3, 2);
}

Math类提供了很多科学和工程计算需要的方法和常数。特殊的运算都需要运用到方法!

4、逻辑运算符

逻辑与：&&和&

逻辑或：||和|

逻辑非：！

【演示】

public static void main(String[] args) {boolean a = true;boolean b = false;System.out.println("a && b = " + (a&&b));System.out.println("a || b = " + (a||b) );System.out.println("!(a && b) = " + !(a && b));
}

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

逻辑与只要有一个为false, 则直接返回false.
逻辑或只要有一个为true, 则直接返回true;

【演示】

public static void main(String[] args){int a = 5;//定义一个变量；boolean b = (a<4)&&(a++<10);System.out.println("使用短路逻辑运算符的结果为"+b);System.out.println("a的结果为"+a);
}

解析：该程序使用到了短路逻辑运算符(&&)，首先判断 a<4 的结果为 false，则 b 的结果必定是 false，所以不再执行第二个操作 a++<10 的判断，所以 a 的值为 5。

5、位运算符

Java定义了位运算符，应用于整数类型(int)、长整型(long)、短整型(short)、字符型(char)和字节型(byte)等类型。位运算符作用在所有的位上，并且按位运算。

A = 0011 1100
B = 0000 1101
-----------------
A&b = 0000 1100
A | B = 0011 1101
A ^ B = 0011 0001
~A= 1100 0011

右移一位相当于除2取商。

左移一位相当于乘2。

【常见面试题：int a=2*8怎样运算效率最快？】

【解析】

public static void main(String[] args) {System.out.println(2 << 3);
}

用移位运算 int a=2<<3：a就是2乘以8，最后结果是16。这是最省内存、最有效率的方法。

这个方法确实高效率的。我来解释一下：2的二进制是10 在32位存储器里面是0000 0000 0000 0010 左移三位后变成 0000 0000 0001 0000 也就是16

解释一下，在系统中运算是以二进制的形式进行的。相比来说俩个二进制数相乘运算比移位运算慢一些。位操作是程序设计中对位模式按位或二进制数的一元和二元操作。在许多古老的微处理器上，位运算比加减运算略快，通常位运算比乘除法运算要快很多。在现代架构中，情况并非如此:位运算的运算速度通常与加法运算相同(仍然快于乘法运算). 详细的需要了解计算机的组成原理！

6、拓展运算符

public static void main(String[] args) {int a=10;int b=20;a+=b; // a = a + bSystem.out.println(a+":"+b);
}

7、字符串连接符

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

//字符串
String s1="Hello 中文!";
String s2=1+""; //转换成String
//int
int c = 12;
System.out.println("c=" + c);

8、三目条件运算符

三目条件运算符，语法格式：

x ? y : z

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

public static void main(String[] args) {int score = 80;String type = score < 60 ? "不及格" : "及格";System.out.println("type= " + type);
}

9、运算符优先级

下表中具有最高优先级的运算符在的表的最上面，最低优先级的在表的底部。

表达式里面优先使用小括号来组织！！方便理解和使用，不建议写非常冗余的代码运算！

public static void main(String[] args) {boolean flag = 1<4*5&&122>3||'q'+3<5;System.out.println(flag);
}

包机制

1、问题发现

存在这样一个问题：当定义了多个类的时候，可能会发生类名的重复问题。

解决方式：在java中采用包机制处理开发者定义的类名冲突问题。

2、包的作用

为了更好地组织类，Java 提供了包机制，用于区别类名的命名空间。

包的作用：

把功能相似或相关的类或接口组织在同一个包中，方便类的查找和使用。
如同文件夹一样，包也采用了树形目录的存储方式。同一个包中的类名字是不同的，不同的包中的类的名字是可以相同的，当同时调用两个不同包中相同类名的类时，应该加上包名加以区别。因此，包可以避免名字冲突。
包也限定了访问权限，拥有包访问权限的类才能访问某个包中的类。

Java 使用包（package）机制是为了防止命名冲突、访问控制、提供搜索和定位类（class）、接口、枚举（enumerations）和注释（annotation）等。

包语句的语法格式为：

package pkg1[．pkg2[．pkg3…]];

例如,一个Something.java 文件它的内容:

package net.java.util;
public class Something{
...
}

那么它的路径应该是 net/java/util/Something.java 这样保存的。

package(包) 的作用是把不同的java 程序分类保存，更方便的被其他 java 程序调用。

一个包（package）可以定义为一组相互联系的类型（类、接口、枚举和注释），为这些类型提供访问保护和命名空间管理的功能。

以下是一些 Java 中的包：

java.lang-打包基础的类
java.io-包含输入输出功能的函数

开发者可以自己把一组类和接口等打包，并定义自己的包。而且在实际开发中这样做是值得提倡的，当你自己完成类的实现之后，将相关的类分组，可以让其他的编程者更容易地确定哪些类、接口、枚举和注释等是相关的。

由于包创建了新的命名空间（namespace），所以不会跟其他包中的任何名字产生命名冲突。使用包这种机制，更容易实现访问控制，并且让定位相关类更加简单。

3、创建包

创建包的时候，需要为包取一个合适的名字。之后，如果其他的一个源文件包含了这个包提供的类、接口、枚举或者注释类型的时候，都必须将这个包的声明放在这个源文件的开头。

包声明应该在源文件的第一行，每个源文件只能有一个包声明，这个文件中的每个类型都应用于它。

如果一个源文件中没有使用包声明，那么其中的类、函数、枚举、注释等将被放在一个无名的包（unnamed package）中。

一般利用公司域名倒置作为包名；

例：www.baidu.com 包名：com.baidu.wwwbbs.baidu.com 包名：com.baidu.bbsblog.baidu.com 包名：com.baidu.blog

4、import关键字

为了能够使用某一个包的成员，需要在 Java 程序中明确导入该包。使用 "import" 语句可完成此功能。

在 java 源文件中 import 语句应位于 package 语句之后，所有类的定义之前，可以没有，也可以有多条，其语法格式为：

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

如果在一个包中，一个类想要使用本包中的另一个类，那么该包名可以省略。

要是要用到其他包下的类，就必须要先导包！

如果两个类重名，需要导入对应的包，否则就需要写出完整地址：

com.kuang.dao.Hello hello = new com.kuang.dao.Hello()

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

import java.io.*;

【不建议这样使用，因为会全局扫描，影响速度！】

使用 import 关键字引入指定类:

import com.kuang.Hello;

【注意】类文件中可以包含任意数量的 import 声明。import 声明必须在包声明之后，类声明之前。

【编码规范：推荐参考阿里巴巴开发手册编程规范】

下载地址：阿里巴巴开发手册

JavaDoc

1、简介

JavaDoc是一种将注释生成HTML文档的技术，生成的HTML文档类似于Java的API，易读且清晰明了。

javadoc是Sun公司提供的一个技术，它从程序源代码中抽取类、方法、成员等注释形成一个和源代码配套的API帮助文档。javadoc命令是用来生成自己API文档的。

使用方式：使用命令行在目标文件所在目录输入 javadoc -encoding UTF-8 -charset UTF-8 文件名.java。

/** 这是一个Javadoc测试程序
* @author Kuangshen
* @version 1.0
* @since 1.5
* */
public class HelloWorld {public String name;/*** @param name 姓名* @return 返回name姓名* @throws Exception 无异常抛出* */public String function(String name) throws Exception{return name;}
}

稍微解释一下：

以 /* 开始，以 / 结束。
@author 作者名
@version 版本号
@since 指明需要最早使用的jdk版本
@param 参数名
@return 返回值情况
@throws 异常抛出情况

2、命令行生成Doc

在文件目录下打开终端，输入以下命令回车即可生成JavaDoc文档。

javadoc -encoding UTF-8 -charset UTF-8 文件名.java
//解决GBK乱码问题，在中间添加编码设置

3、使用IDEA生产javaDoc

首先我们需要新建一个文件夹用于存放JavaDoc的文件,接下来点击IntelliJ IDEA顶部的Tools菜单，选择Generate JavaDoc选项，如下图所示:

如下图

「JavaSE」-基础语法相关推荐

[免费专栏] Android安全之APK应用程序分析「附带Smali基础语法解析」
也许每个人出生的时候都以为这世界都是为他一个人而存在的,当他发现自己错的时候,他便开始长大少走了弯路,也就错过了风景,无论如何,感谢经历 Android安全付费专栏长期更新,本篇最新内容请前往: [ ...
Linux后台开发系列之「09.Makefile 基础语法」
Makefile 版权声明:本文为 cdeveloper 原创文章,可以随意转载,但必须在明确位置注明出处! Makefile 简介 Makefile 是一个管理项目的配置文件,它主要有 2 个作用: ...
CSS基础「一」基础选择器 / 字体属性 / 文本属性 / 三种样式表
前言:本篇文章为 CSS 基础系列笔记第一篇,参考黑马程序员pink老师前端入门教程如有侵权联系删除,如有问题欢迎指出. 其他CSS基础相关文章: CSS基础「二」复合选择器 / 元素显示模式 / ...
「转」二级语法知识总结
二级语法知识总结(一) 来源:沪江论坛 | 时间:2005-06-27 | 作者:nagayama[转帖] | (1) 一からといって/虽说-却不- 不要因为-而- 「100%ではない,正しい理 ...
JavaSE——Java基础语法（二进制、变量、方法（函数）、运算符、转义字符）
第2节基础语法一.二进制 1.1 二进制介绍计算机中的数据都以二进制数字保存. 二进制 :逢二进一,即只有0.1两个值.如十进制的10在计算机内保存为二进制的1010. 计算机中信息的存储单位: ...
「JavaSE」- 常用类
常用类 Object类 Object是所有类的父类,任何类都默认继承Object.理论上Object类是所有类的父类,即直接或间接的继承java.lang.Object类.由于所有的类都继承在Obje ...
「JavaSE」- GUI编程
GUI 编程 Swing和AWT 是java开发GUI常用的技术,但是由于外观不太美观, 组件数量偏少, 并且运行需要JRE环境(动不动就上百M的JRE包....), 所以没有流行起来.但是 ,建议简 ...
「MySQL」- 基础增删改查
目录前言新增/插入 ( insert ) 查询 ( select ) 1. 查询所有列 2.查询指定列 3.查询表达式字段 4.查询字段指定别名 5.去重查询 6.排序查询 7.条件查询条件运算 ...
「JavaSE」-流程控制和方法
流程控制用户交互Scanner 1.Scanner对象之前我们学的基本语法中我们并没有实现程序和人的交互,但是Java给我们提供了这样一个工具类,我们可以获取用户的输入.java.util.Sca ...

「JavaSE」-基础语法

Java基础语法

注释

标识符

数据类型

1、强弱类型语言

2、数据类型

3、整数拓展

4、浮点数拓展

5、字符拓展

6、布尔值拓展

类型转换

1、自动类型转换

2、强制类型转换

3、常见错误和问题

4、JDK7拓展

变量 常量

1、变量（variable）

2、变量作用域

3、常量

4、变量的命名规范

运算符

1、二元运算符

2、取模运算

3、一元运算符

4、逻辑运算符

5、位运算符

6、拓展运算符

7、字符串连接符

8、三目条件运算符

9、运算符优先级

包机制

1、问题发现

2、包的作用

3、创建包

4、import关键字

JavaDoc

1、简介

2、命令行生成Doc

3、使用IDEA生产javaDoc

「JavaSE」-基础语法相关推荐

最新文章

热门文章

变量常量