1. 标识符
标识符的命名规则:
- 可以有大小写字母,0-9的阿拉伯数字,下划线_,美元符号$
- 数字不能开头
- 不能用Java中的50个关键字和保留字段的3个特殊值
- Java严格区分大小写
- 不能使用空格
标识符命名规范
- 包所有字母都小写
- 类名/接口名:所有单词首字母大写
- 变量名/方法名:第一个首字母小写,其余单词首字母大写
- 常量名:所有字母都大写,每个单词用_连接
2. 变量
概念:代码一块运行空间,使用变量名来访问和使用这块内存空间
变量的类型
- 局部变量:定义在方法,构造方法,语句块中的变量,不能被修饰符修饰
- 成员变量:定义在类之内,方法之外的变量,可以被访问修饰符修饰
- 静态变量:定义在类之中,方法之外的变量,并且使用static关键字修饰
- 参数变量:方法定义时声明的变量,作为调用该方法时传递给方法的值
accModiier returnType methodName(parameterType parameterName1,parameterType parameterName2)
- parameterType表示参数变量的类型
- parameterName表示参数变量的名字
变量的作用
- 概念:一块内存中的数据空间的表示
- 作用:保护数据
变量的注意事项
- 变量应该先声明后使用
- 变量要有初始值
- 变量有作用域和生命周期
变量的作用域和生命周期
- 局部变量:作用域只限于当前方法,构造方法,语句块中,保存在栈中,在变量所在的函数或模块被执行时动态创建,执行完时,变量对应的内存空间被释放
- 成员变量:作用域为整个类
- 静态变量:作用域为整个类
- 参数变量:作用域只限于方法内部
- 成员变量和静态变量都存储在静态存储区中,在编译时分配内存空间并进行初始化,在程序运行时一直存在,直到程序结束,变量对应的空间才被释放
常量
变量使用 final修饰的变量,常量在编译时就已经确定了他的值并且不能被修改
public final MAX_COUNT = 100
3. 数据类型
- 基本数据类型
整数型:byte,short int,long
浮点型:float,double
字符型:char
布尔型:boolean
- 基本数据类型的取值范围
- byte的取值范围是-128~127
- short的取值范围是-32768~32767
- int的取值范围是-2147483648~2147483647
- long的取值范围是-9223372036854775808~9223372036854775807(Long类型在写的时候要加上L,比如:long a =10000L;)
- 引用数据类型
类:System,String
接口,数组
- 类型转换
数据类型的大小排序:byte<shor,char<int<long<float<double
自动类型转换:必须满足转换前的数据类型的位数要低于转换后的数据类型
比如:float类型的变量可以自动转换成double类型的变量
强制类型转换:转换的数据必须是兼容的,
int i=123; byte = b = (byte)i;
隐式类型转换:整数的默认类型是int,小数的默认类型是double,在定义float类型的时候后面要跟上F或f
4. 运算符
4.1. 算术运算符
操作符 | 描述 |
+ | 加法,相加运算两侧的值 |
- | 减法,左操作数减去右操作数 |
* | 乘法,相乘操作符两侧的值 |
/ | 除法,左操作数除以右操作数 |
% | 取余,左操作数除以右操作数的余数 |
++ | 自增,操作数的值加1 |
-- | 自减,操作数的值减1 |
public class selfAddMinus{
public static void main(String[] args){
int a = 5;//定义一个变量;
int b = 5;
int x = 2*++a;//相当于2*6
int y = 2*b++;//相当于2*5
System.out.println("自增运算符前缀运算后a="+a+",x="+x);
System.out.println("自增运算符后缀运算后b="+b+",y="+y);
}
}
4.2.关系运算符
运算符 | 描述 |
|
== | 检查两个操作数的值是否相等,如果相等则条件为真 | |
!= | 检查如果两个操作数的值是否相等,如果值不相等则条件为真。 |
|
> | 检查左操作数的值是否大于右操作数的值,如果是那么条件为真。 |
|
< | 检查左操作数的值是否小于右操作数的值,如果是那么条件为真。 |
|
>= | 检查左操作数的值是否大于或等于右操作数的值,如果是那么条件为真。 |
|
<= | 检查左操作数的值是否小于或等于右操作数的值,如果是那么条件为真。 |
|
4.3.位运算符
A = 0011 1100
B = 0000 1101
-----------------
A&B = 0000 1100
A | B = 0011 1101
A ^ B = 0011 0001
~A= 1100 0011
操作符 | 描述 | 例子 |
& | 如果相对应位都是1,则结果为1,否则为0 | (A&B),得到12,即0000 1100 |
| | 如果相对应位都是 0,则结果为 0,否则为 1 | (A | B)得到61,即 0011 1101 |
^ | 如果相对应位值相同,则结果为0,否则为1 | (A ^ B)得到49,即 0011 0001 |
〜 | 按位取反运算符翻转操作数的每一位,即0变成1,1变成0。 | (〜A)得到-61,即1100 0011 |
<< | 按位左移运算符。左操作数按位左移右操作数指定的位数。 | A << 2得到240,即 1111 0000 |
>> | 按位右移运算符。左操作数按位右移右操作数指定的位数。 | A >> 2得到15即 1111 |
>>> | 按位右移补零操作符。左操作数的值按右操作数指定的位数右移,移动得到的空位以零填充。 | A>>>2得到15即0000 1111 |
4.4.逻辑运算符
操作符 | 描述 | 例子 |
&& | 称为逻辑与运算符。当且仅当两个操作数都为真,条件才为真。 | (A && B)为假。 |
| | | 称为逻辑或操作符。如果任何两个操作数任何一个为真,条件为真。 | (A | | B)为真。 |
! | 称为逻辑非运算符。用来反转操作数的逻辑状态。如果条件为true,则逻辑非运算符将得到false。 | !(A && B)为真。 |
4.5.三元运算符
variable x = (expression) ? value if true :value if false;
public class Test{
public static void main(String[]args){
int a,b;
a=10;
//如果a=1成立,那么b=20,否则b=30;
b=(a==1)?20:30;
System.out.println("Value of b is" +b);
//如果a=10成立,那么b=20否则b=30;
b=(a==10)?20:30;
System.out.println("Value of b is" +b);
}
}
4.6instanceof运算符
该操作符用于操作对象实例,检查该对象是否是一个特定类型(类类型,接口类型)
(Object reference variable) instanceof (class/interface type)
如果instanceof左侧的对象实例,与右侧的类或接口类型相同,那么结果为真
class Vehicle {}
public class Car extends Vehicle {
public static void main(String[] args){
Vehicle a = new Car();
boolean result = a instanceof Car;
System.out.println( result);
}
}
4.7.运算符的优先级
()>算术运算符>关系运算符>逻辑运算符>三元运算符>赋值运算符
5. 流程控制结构
Java的程序执行顺序是按照代码书写从上到下从左到右依次执行的
5.1.条件语句
5.1.1 if语句
if(布尔表达式){
//如果布尔表达式为true将执行的语句
}
5.1.2 if-else语句
if语句后面可以跟else语句,当if语句的布尔表达式值为false时,else语句会被执行
if(布尔表达式){
//如果布尔表达式为true
}else{
//如果布尔表达式为false
}
5.1.3 if...else if...else语句
if后面可以跟if-else语句,if语句至多有1个else语句,else语句必须在所有的else-if语句后面
if(布尔表达式1){
//如果布尔表达式1true执行此代码
}else if(布尔表达式2){
//如果布尔表达式2true执行此代码
}else if(布尔表达式3){
//如果布尔表达式3true执行此代码
}else{
//如果以上布尔表达式都为false执行此代码
}
5.1.4 嵌套的if语句
if(布尔表达式 1){
如果布尔表达式 1的值为true执行代码
if(布尔表达式 2){
如果布尔表达式 2的值为true执行代码
}
}
public class Test {
public static void main(String args[]){
int x = 30;
int y = 10;
if( x == 30 ){
if( y == 10 ){
System.out.print("X = 30 and Y = 10");
}
}
}
}
5.1.5 switch语句
switch case语句的语法格式
switch(expression){
case value :
//语句
break; //可选
case value :
//语句
break; //可选
//你可以有任意数量的case语句
default : //可选
//语句
}
switch case的语法规则
- switch的变量类型可以是byte,short,int,或者char,从JavaSE7开始,switch支持字符串同时,case标签必须为字符常量或字面量
- switch语句可以同时拥有多个case语句,每个case后面跟一个要比较的值或冒号
- case语句的值的数据类型要和变量的数据类型相同,而且只能是常量或者字面常量
- 当变量的值与case语句的值相等,那么case语句开始执行,直到break才会跳出switch语句
- case语句不必须包含break语句,如果没有break语句,程序会继续执行下一条case语句,直到出现break语句
- switch语句可以包含一个default语句,该语句一般是switch语句的最后一句,default在没有case语句执行的时候执行,default不需要break语句
public class Test {
public static void main(String args[]){
//char grade = args[0].charAt(0);
char grade = 'C';
switch(grade)
{
case 'A' :
System.out.println("优秀");
break;
case 'B' :
case 'C' :
System.out.println("良好");
break;
case 'D' :
System.out.println("及格");
break;
case 'F' :
System.out.println("你需要再努力努力");
break;
default :
System.out.println("未知等级");
}
System.out.println("你的等级是 " + grade);
}
}
5.1.6 if语句和switch语句的区别
- if语句:表达式结果是boolean类型,常用于区间判断
- switch语句:表达式类型不能是boolean,可以是 byte short int char,String,枚举类型的,常用于等值判断
5.2循环语句
循环的好处:代码简洁,易修改
5.2.1 while循环
while(布尔表达式){
//循环内容
}
//只要布尔表达式为true,就会一直执行下去
5.2.2 do...while循环
do...while循环至少会执行一次
do{
//代码语句
}while(布尔表达式)
布尔表达式在循环体的后面,所以语句在检测布尔表达式之前已经执行了
5.2.3 for循环
for循环执行的次数是在执行前就确定了
for(初始化;布尔表达式;更新){
}
for循环执行顺序:
- 最先初始化变量,可以声明一种类型,但可以初始化一种或多种初始化循环变量,也可以是空语句
- 然后检测布尔表达式的值,如果为true,循环体被执行,如果为false循环终止,开始执行循环体后面的语句
- 执行一次循环后,更新循环控制变量
- 再次检测布尔表达式,循环上面的过程
5.2.4 增强for循环
Java5 引入了一种主要用于数组的增强型 for 循环。
for(数据类型 变量名:要访问的数组名){
//代码块
}
5.2.5 break关键字
break主要用于循环语句或者switch语句当中,用来跳出整个语句块
break跳出最里面的循环,并接着执行循环下面的语句
public class Test {
public static void main(String[] args) {
int [] numbers = {10, 20, 30, 40, 50};
for(int x : numbers ) {
// x 等于 30 时跳出循环
if( x == 30 ) {
break;
}
System.out.print( x );
System.out.print("\n");
}
}
}
//输出 10 20;
5.2.6 continue关键字
continue适用于任何循环控制结构中,作用是让程序跳出本次循环,进入下次循环当中
在for循环当中,continue语句使程序跳转到更新语句
在while循环或do...while当中,程序立即跳转到布尔表达式的判断语句
public class Test {
public static void main(String[] args) {
int [] numbers = {10, 20, 30, 40, 50};
for(int x : numbers ) {
if( x == 30 ) {
continue;
}
System.out.print( x );
System.out.print("\n");
}
}
}
5.2.7 return关键字
return:从当前方法中跳出,返回到调用方法处继续执行
6. 方法
6.1 方法概述
概述:具有特点功能的代码块
- 方法是解决一类问题的步骤的有序组合
- 方法包含于类或对象中
- 方法在程序中被创建,在其他地方被引用
6.2 方法的优点
- 使程序变的更简短而清晰
- 有利于程序维护
- 可以提高开发的效率
- 提高了代码的复用性
6.3 方法的定义
修饰符 返回值类型 方法名(参数类型 参数名){
...
方法体
...
return 返回值;
}
- 修饰符:修饰符,是可选的,告诉编译器如果调用该方法,定义了该方法的访问类型
- 返回值类型:方法可能会返回值,returnValueType是方法返回值的类型,有些方法执行体所需的操作,但没有返回值,在这种情况下,返回值类型是void
- 方法名:是方法的实际名称,方法名和参数列表共同构成方法签名
- 参数类型:参数像是一个占位符,当方法被调用时,传递值给参数,这个值被称为实参或变量,参数列表是指方法的参数类型,顺序和参数个数,方法可以不包括任何参数
- 方法包含具体的语句,定义该方法的功能
public static int age(int birthday){...}
6.4 方法的调用
Java支持两种调用方法的方式,根据方法是否返回值来选择
形参:方法用于外界声明,执行功能的时候,需要几个哪些类型的数据
实参:方法真正被调用的时候,传递给方法实实在在的数据
方法不能嵌套定义,但可以嵌套调用
6.5 方法的重载
方法重载可以让程序更清晰易读,执行密切相关任务的方法应该使用相同的名字
重载的方法必须拥有不同的参数列表,与返回值类型无关和修饰符无关
重载的所有方法必须在同一个类当中
6.6 可变参数
JDK 1.5 开始,Java支持传递同类型的可变参数给一个方法。
一个方法中只能指定一个可变参数,它必须是方法的最后一个参数。任何普通的参数必须在它之前声明。
public class VarargsDemo {
public static void main(String[] args) {
// 调用可变参数的方法
printMax(34, 3, 3, 2, 56.5);
printMax(new double[]{1, 2, 3});
}
public static void printMax( double... numbers) {
if (numbers.length == 0) {
System.out.println("No argument passed");
return;
}
double result = numbers[0];
for (int i = 1; i < numbers.length; i++){
if (numbers[i] > result) {
result = numbers[i];
}
}
System.out.println("The max value is " + result);
}
}
6.7 构造方法
当一个对象被创建时候,构造方法用来初始化该对象。构造方法和它所在类的名字相同,但构造方法没有返回值。
不管你是否自定义构造方法,所有的类都有构造方法,因为 Java 自动提供了一个默认构造方法,默认构造方法的访问修饰符和类的访问修饰符相同(类为 public,构造函数也为 public;类改为 protected,构造函数也改为 protected)。
一旦你定义了自己的构造方法,默认构造方法就会失效。
6.8 finalize()方法
Java 允许定义这样的方法,它在对象被垃圾收集器析构(回收)之前调用,这个方法叫做 finalize( ),它用来清除回收对象。
例如,你可以使用 finalize() 来确保一个对象打开的文件被关闭了。
在 finalize() 方法里,你必须指定在对象销毁时候要执行的操作。
public class FinalizationDemo {
public static void main(String[] args) {
Cake c1 = new Cake(1);
Cake c2 = new Cake(2);
Cake c3 = new Cake(3);
c2 = c3 = null;
System.gc(); //调用Java垃圾收集器
}
}
class Cake extends Object {
private int id;
public Cake(int id) {
this.id = id;
System.out.println("Cake Object " + id + "is created");
}
protected void finalize() throws java.lang.Throwable {
super.finalize();
System.out.println("Cake Object " + id + "is disposed");
}
}
Java的内存回收一般是由JVM自动完成 如果想要手动回收Java的内存可以使用finalize方法