Java基本语法入门

Java运行原理

• 首先我们写的.java源文件，放入java虚拟机(JVM)中运行，生成.class字节码文件，这个文件可以放到java虚拟机上运行，java虚拟机有java文件运行所需要的环境，即java运行环境(jre)，这样在不同的操作系统上，只要有Java虚拟机就可以运行java文件
  
  

一、Java基础语法

1、标识符

标识符指的是java文件中的类名、变量名以及方法名。

标识符的命名规则

1. 所有的标识符都应该以字母(A-Z或者a-z)，美元符($)、或者下划线(_)开始。
2. 首字符之后可以是任何字符的组合
3. 关键字不能用作标识符
4. 标识符的大小是敏感的
5. 不能以数字开头

2、类的声明与实例化

类的声明

• 声明语法
• 类的声明：类名 对象名
• 类的声明和基本类型的数据声明的形式上是一样的。
• 对象名遵循标识符的命名规则

类的实例化

• 用new关键字创建一个新对象，即进行实例化
• new 构造方法[参数列表]
• 实例化过程就是为对象分配内存空间的过程，此时，对象才成为类的实例。new所执行的具体操作是调用相应类中的构造方法(包括父类的构造方法)，来完成内存分配以及变量的初始化工作，然后将分配的内存地址返回给所定义的变量。
• 实质：实例化了就有自己内存空间。而没有实例化就和引用的对象内存空间地址相同，指向同一个空间。

3、变量的声明与使用

变量的声明

• 声明语法：
• 数据类型 变量名；
• 赋值：
• 变量名 = 值

变量的使用

• 变量的使用有很多
• 在基本数据类型声明的变量，可以进行数据的赋值、运算等等。

4、函数的声明和使用

函数的声明

1.java中的函数也叫方法，类似于C语言中的函数，它的声明格式为：
[修饰符] [返回值类型] [方法名] (形式参数列表)
{
函数内容；
[return 返回值]；
}
2. 函数的参数列表可以是有参数的，也可以是没有参数的。
3. 使用函数的好处：提高代码的复用性
4. 有参函数是指()中包含一个或多个变量定义，也称为参数列表
5. 无参函数是指()中不含参数

参数分两种：
形式参数(形参)：在方法定义时用于接收外界输入的数据。
实际参数(实参)：调用方法时实际传给方法的数据。
6.函数的返回值：

• 如果该函数没有返回值则返回值类型为void
• 如果该函数有返回值，在方法中必须使用关键字return返回该值。
  return 表达式；(作用：跳出函数，返回结果)

函数的使用

1. 直接调用：函数名(实参列表)；//调用的前提是该函数存在于当前类中。
2. 类名调用：类名.函数名(实参列表)；//调用的前提是该函数属于静态方法(也就是用static修饰函数)
3. 对象调用：对象.方法名(实参列表)；

基本数据类型

• 变量就是申请内存来存储值。也就是说，当创建变量的时候，需要在内存中申请空间。内存管理系统根据变量的类型为变量分配存储空间，分配的空间只能用来储存该类型数据。因此，通过定义不同类型的变量，可以在内存中存储整数、小数或者字符。

Java的两大数据类型:

• 内置数据类型
• 引用数据类型

内置数据类型

Java语言提供了八种基本类型。六种数字类型(四个整数型，两个浮点型)，一种字符类型，还有一种布尔类型。

	范围	默认值	特征
byte	-128(-2^ 7)~127(2^7-1)	0	byte数据类型是8位、有符号的，以二进制补码表示的整数------------(例子:byte a =100)
short	-32768(-2^ 15)~32767(2^15-1)	0	short数据类型是16位、有符号的以二进制补码表示的整数----------(例子：short s = 1000)
int	-2,147,483,648(-2^ 31)~-2,147,483,647(2^31-1)	0	int数据类型是32位、有符号的以二进制补码表示的整数；(例子：int a = 100000)
long	-9,223,372,036,854,775,808(-2^ 63)~-9,223,372,036,854,775,807(2^63-1)	0	long数据类型是64位、有符号的以二进制补码表示的整数(例子：long a = 100000L)
float	浮点数不能用来表示精确的值	0.0f	float数据类型是单精度、32位、符合IEEE 754标准的浮点数(例子：float f1 = 234.5f)
double	浮点数的默认类型为double类型	0.0d	double数据类型是双精度、64位、符合IEEE 754标准的浮点数(例子：double d1 = 123.4)
boolean	这种类型只作为一种标志来记录true/false情况	false	只有两个取值：true和false----------------------------(例子：boolean one = true)
char	最小值‘\u0000’(即为0)-最大值‘\uffff’(即为65535)	char数据类型可以储存任何字符	char类型是一个单一的16位Unicode字符(例子：char letter = ‘A’)

运算符

• 算数运算符
• 关系运算符
• 位运算符
• 逻辑运算符
• 赋值运算符
• 其他运算符

算术运算符

操作符	描述
+	加法 - 相加运算符两侧的值
-	减法 - 左操作数减去右操作数
*	乘法 - 相乘操作符两侧的值
/	除法 - 左操作数除以右操作数
%	取模 - 左操作数除以右操作数的余数
++	自增 - 操作数的值增加1
–	自减 - 操作数的值减少1

关系运算符

运算符	描述
==	检查如果两个操作数的值是否相等，如果相等则条件为真。
!=	检查如果两个操作数的值是否相等，如果值不相等则条件为真。
>	检查左操作数的值是否大于右操作数的值，如果是那么条件为真。
<	检查左操作数的值是否小于右操作数的值，如果是那么条件为真。
>=	检查左操作数的值是否大于或等于右操作数的值，如果是那么条件为真。
<=	检查左操作数的值是否小于或等于右操作数的值，如果是那么条件为真。

位运算符

假如 a=60,b=13

操作符	描述	例子
&	按位与操作符，当且仅当两个操作数的某一位都非0时候结果的该位才为1。	（A＆B），得到12，即0000 1100
\	按位或操作符，只要两个操作数的某一位有一个非0时候结果的该位就为1。	（A 竖 B）得到61，即 0011 1101
^	按位异或操作符，两个操作数的某一位不相同时候结果的该位就为1。	（A ^ B）得到49，即 0011 0001
~	按位补运算符翻转操作数的每一位。	（〜A）得到-60，即1100 0011
<<	按位左移运算符。左操作数按位左移右操作数指定的位数。	A << 2得到240，即 1111 0000
>>	按位右移运算符。左操作数按位右移右操作数指定的位数。	A >> 2得到15即 1111
>>>	按位右移补零操作符。左操作数的值按右操作数指定的位数右移，移动得到的空位以零填充。	A>>>2得到15即0000 1111

逻辑运算符

操作符	描述	例子
&&	称为逻辑与运算符。当且仅当两个操作数都为真，条件才为真。	（A && B）为假。
\\	称为逻辑或操作符。如果任何两个操作数任何一个为真，条件为真。	（A \\ B）为真。
!	称为逻辑非运算符。用来反转操作数的逻辑状态。如果条件为true，则逻辑非运算符将得到false。	！（A && B）为真。

赋值运算符

操作符	描述	例子
=	简单的赋值运算符，将右操作数的值赋给左侧操作数	C = A + B将把A + B得到的值赋给C
+=	加和赋值操作符，它把左操作数和右操作数相加赋值给左操作数	C + = A等价于C = C + A
-=	减和赋值操作符，它把左操作数和右操作数相减赋值给左操作数	C - = A等价于C = C -A
*=	乘和赋值操作符，它把左操作数和右操作数相乘赋值给左操作数	C * = A等价于C = C * A
/=	除和赋值操作符，它把左操作数和右操作数相除赋值给左操作数	C / = A等价于C = C / A
%=	取模和赋值操作符，它把左操作数和右操作数取模后赋值给左操作数	C％= A等价于C = C％A
<<=	左移位赋值运算符	C << = 2等价于C = C << 2
>>=	右移位赋值运算符	C >> = 2等价于C = C >> 2
&=	按位与赋值运算符	C＆= 2等价于C = C＆2
^=	按位异或赋值操作符	C ^ = 2等价于C = C ^ 2
\ =	按位或赋值操作符	C \ = 2等价于C = C \ 2

条件运算符

条件运算符也称为三元运算符
x = (a > b)? c : d

instanceOf运算符

该运算符用于操作对象实例，检查该对象是否是一个特定类型（类类型或接口类型）

Java运算符优先级

类别	操作符	关联性
后缀	() [] . (点操作符)	左到右
一元	+ + - ！〜	从右到左
乘性	*/%	左到右
加性	±	左到右
移位	>> >>> <<	左到右
关系	>> = << =	左到右
相等	== !=	左到右
按位与	&	左到右
按位异或	^	左到右
按位或	\	左到右
逻辑与	&&	左到右
逻辑或	\\	左到右
条件	？：	从右到左
赋值	= + = - = * = / =％= >> = << =＆= ^ = \ =	从右到左
逗号	,	左到右

修饰符

• 访问修饰符
• 非访问修饰符

访问修饰符

• 默认的，default （在同一包内可见，不使用任何修饰符）

• 私有的，private（在同一类内可见）

• 共有的，pulbic（对所有类可见）

• 受保护的，protected （对同一包内的类和所有子类可见）

访问控制与继承

子类的权限修饰符必须比父类权限修饰符大
父：public 子：public
父：protected 子：protected/public
父：默认 子：private
父：private 子：不能被继承

非访问修饰符

• static修饰符，用来创建类方法和类变量。
• final修饰符，用来修饰类、方法和变量，final修饰的类不能够被继承，修饰的方法不能被继承类重新定义，修饰的变量为常量，是不可修改的。
• abstract修饰符，用来创建抽象类和抽象方法。
• synchronized和volatile修饰符，主要用于线程的编程。

static修饰符

- 静态变量
static关键字用来声明独立于对象的静态变量，无论一个类实例化多少对象，它的静态变量只有一份拷贝。静态变量也被称为类变量。局部变量不能被声明为static变量。

- 静态方法
static关键字用来声明独立于对象的静态方法。静态方法不能使用类的非静态变量。静态方法从参数列表得到数据，然后计算这些数据。

final修饰符

- final变量
final变量能被显式地初始化并且只能初始化一次。被声明为final的对象的引用不能指向不同的对象。但是final对象里的数据可以被改变。也就是说final对象的引用不能改变，但是里面的值可以改变。

final修饰符通常和static修饰符一起使用来创建类常量。

- final方法
类中的Final方法可以被子类继承，但是不能被子类修改。

声明final方法的主要目的是防止该方法的内容被修改。

- final类
final类不能被继承，没有类能够继承final类的任何特性。

abstract修饰符

抽象类：

• 抽象类不能用来实例化对象，声明抽象类的唯一目的是为了将来对该类进行扩充。

• 一个类不能同时被abstract和final修饰。如果一个类包含抽象方法，那么该类一定要声明为抽象类，否则将出现编译错误。

• 抽象类可以包含抽象方法和非抽象方法。

抽象方法：

• 抽象方法是一种没有任何实现的方法，该方法的的具体实现由子类提供。抽象方法不能被声明成final和static。

• 任何继承抽象类的子类必须实现父类的所有抽象方法，除非该子类也是抽象类。

• 如果一个类包含若干个抽象方法，那么该类必须声明为抽象类。抽象类可以不包含抽象方法。

• 抽象方法的声明以分号结尾，例如：public abstract sample();

synchronized修饰符

• synchronized关键字声明的方法同一时间只能被一个线程访问。Synchronized修饰符可以应用于四个访问修饰符。

transient修饰符

• 序列化的对象包含被transient修饰的实例变量时，java虚拟机(JVM)跳过该特定的变量。

• 该修饰符包含在定义变量的语句中，用来预处理类和变量的数据类型。

volatile修饰符

• volatile修饰的成员变量在每次被线程访问时，都强迫从共享内存中重读该成员变量的值。而且，当成员变量发生变化时，强迫线程将变化值回写到共享内存。这样在任何时刻，两个不同的线程总是看到某个成员变量的同一个值。一个volatile对象引用可能是null。

Java注释

单行注释

//

多行注释

/* */

文档注释

/** */

5、流程跳转

for、while、do{}while、增强for循环

break

• break主要用于循环语句或者switch语句中，用来跳出整个语句块
• break跳出最里层的循环，并且继续执行该循环下面的语句

continue

• continue适用于任何循环控制结构中。作用是让程序立刻跳转到下一次循环的迭代。

• 在for循环中，continue语句使程序立即跳转到更新语句。

• 在while或者do…while循环中，程序立即跳转到布尔表达式的判断语句。

if…else/switch…case

• switch语句中变量类型只能为byte、short、int、char

switch(expression){
	case value : break;
	default :
}

6、Java变量

1.局部变量

• 局部变量声明在方法、构造方法或者语句块中；
• 局部变量在方法、构造方法、或者语句块被执行的时候被创建，当它们执行完成，变量会被销毁。
• 访问修饰符不能用于局部变量
• 局部变量(作用域)只在声明它的方法，构造方法或者语句块中可见
• 局部变量是在栈上分配的
• 局部变量没有默认值，所以局部变量被声明后，必须经过初始化，才能使用

2.类变量(静态变量)

• static关键字修饰，必须在方法、构造方法、语句块外。
• 常量是指被声明位public/private/static/final变量，常量初始化后不可改变。
• 在程序开始时被创建，在程序结束时销毁
• 被分配到静态存储区

3.成员变量(实例变量)

• 实例变量声明在一个类中，但在方法、构造方法和语句块之外
• 实例变量在对象创建时创建，在对象被销毁的时候销毁
• 访问修饰符可以修饰实例变量
• 具有默认值。
• 类变量被声明为public static final类型时，类变量名称必须使用大写字母。如果静态变量不是public和final类型，其命名方式与实例变量以及局部变量的命名方式一致。

7、Java内部类

• 内部类的实例只能存在于其封闭类的实例中。

1. 内部类的优点
   • 再将使用它们的其他类附近定义类
   • 提供了一个额外的命名空间来管理类结构。
   • 一些设计模式使用内部类更容易实现
   • 实现回调机制使用内部类是优雅和方便的，它有助于Java中实现闭包。

• 内部类与继承

1. 内部类可以继承另一个内部类、顶级类或其封闭类。

class A{
	public class B{
	}
	public class c extends B{
	}
	public class D extends A{
	}
}
class E extends A{
	public class F extends B{
	}
}

• 内部类中没有静态成员
  - Java中的关键字static是一个构造成为一个顶层结构。
  - 因此，我们不能为内部类声明为任何静态成员(字段、方法或初始化器)。
  - 允许在内部类中有作为编译时常量的静态字段。

class A{
	public class B{
			public final static int DAYS_IN_A_WEEK = 7;
	}
}

• 生成的内部类的类文件
  1. 每个内部类都被编译成一个单独的类文件。
• 成员内部类和静态内部类的类文件名格式如下：

<outer-class-name>$<member-or-static-inner-class-name>

• 局部内部类的类文件名的格式如下

<outer-class-name>$<a-number><local-inner-class-name>

• 匿名类的类文件名的格式如下：

<outer-class-name>$<a-number>

成员内部类

• 声明为类中、方法体、代码块之外。和成员变量、成员方法在同一级别。

public class Bird{
	public int a = 1;
	public class Yanzi{
	public int a = 2
	
		public void fly(){
			sout(a);
			sout(Bird,this.a)
		}
	}
}
实例化成员内部类：

Bird b = new Bird();
Bird.Yanzi yanzi = b.new Yanzi();

局部内部类

• 一个局部内部类在块中声名，其范围仅限于声明它的块
• 其范围限于其封闭块，因此声明不能使用任何修饰符
• 在方法内定义局部内部类。
• 在静态初始化器和非静态初始化器和构造器中定义

静态内部类

• 声明位置与成员内部类相同

public class out{
	public static class Inner{
	
	}
}
实例化静态内部类的对象
Out.Inner inner = new Out.Inner();

匿名内部类

• 匿名内部类没有名称。他不能有一个构造函数。
• 匿名类是一次性的类。定义一个匿名类并同时创建它的对象。
• 创建匿名类及其对象的语法如下：

new Inteface(){

}

• 接口里的变量都隐式声明为public static final
• 类和接口不能声明为private
• protected访问修饰符不能修饰类和接口
• final修饰的方法不能被继承
• 声明为final的对象的引用不能指向不同的对象，但final对象里的数据可以被改变。
• final的方法可以被子类继承，但不能被子类修改
• final类不能被继承
• 一个类不能同时被abstract和final修饰
• 抽象方法不能被声明为static和final
• switch语句中的变量类型只能为byte、short、int、char
• 一个子类只能有一个父类
• 一个父类可以有多个子类
• 重写：子类方法的权限必须大于父类方法的权限
• 接口不能包含成员变量，除了static和final变量