java基本语法
主函数
class Test {
public static void main(String[] args) {
// 程序的代码
}
}
注释
注释是对代码的解释说明，不是编程语句，因此被编译器忽略，不参与程序运行。
- 书写注释是一个必要的习惯，平时写代码一定要注意规范
- Java的注释有三种
-
单行注释（即在程序中注释一行代码）
-
多行注释（即一次性地将程序中多行代码注释掉）
-
文档注释（使用特殊的文档格式将文档内容写在代码中，然后可以使用Javadoc将这些文档提取出来）
-
//单行注释
/*
多行
注释
*/
/**
文档
注释
*/
- 可读性第一，效率第二，代码即文档
*文档注释以后再补充点??️
分隔符
Java语言中，分号（ ; ）、花括号（ {} ）、方括号（ [] )、圆括号（()）、空格、圆点（.）都具有特殊的分隔作用，因此被统称为分隔符。
-
分号
Java语言中，对语句的分隔不是通过使用回车来完成的，采用分号（;）来作为语句的分隔，所以每个Java语句都必须使用分号（;)作为结尾。Java程序允许一行书写多个语句，每个语句间用分号隔开即可；一个语句也可跨多行，只要在最后结束的地方使用分号结束即可。
注意：Java语句可以跨多行书写，但一个字符串、变量名不能跨多行。 -
花括号
花括号的作用是定义一个代码块，一个代码块指的是“{”和“}”里面包含的一段代码，代码块在逻辑上是一个整体。在Java语言中，类定义部分必须放在一块代码块里，方法体部分也必须放在一个代码块里。此外，条件语句中的条件执行体和循环语句中的循环体通常是放在代码块里。 -
方括号
方括号的主要作用是用于访问数组元素，方括号通常紧跟数组变量名，而方括号里指定希望访问的数组元素的索引。 -
圆括号
圆括号是一个功能很丰富的分隔符：
定义方法时必须使用圆括号来包含所有的形参声明
调用方法时必须使用圆括号来传入实参值
将表达式中某个部分括成一个整体，保证该部分优先计算
作为强制类型转换的运算符
- 空格
Java语言使用空格分隔一条语句的不同部分。Java语言是的格式是自由的，所以空格几乎可出现在Java程序中的任何地方，也可出现任意多个空格，但不要使用空格把一个变量名隔开成两个，将导致程序出错。
**Java语言中的空格包含空格符(Space)、制表符(Tab)、回车（Enter)等 - 圆点
圆点通常用作类/对象和它的成员（包括成员变量、方法、内部类）之间的分隔符，表明调用某个类/某个实例的指定成员。
标识符和关键字
Java语言和其他编程语言一样，使用标识符作为变量、对象的名字，也提供了系列的关键字来实现特别的功能。
标识符
Java所有的组成部分都需要名字。标识符就是用于给程序中变量、类、方法命名的符号。
标识符注意点：
- 所有的标识符都应以字母（A-Z或a-z）、美元符（$）、下划线（_)开始
- 首字符之后可以是字母（A-Z或a-z）、美元符（$）、下划线（_)或数字的任何字符组合
- 标识符不能包含空格
- 标识符不能是Java关键字，但可以包含关键字
- 标识符是大小写敏感的
- 合法标识符举例：age,$salary,_value,__1_value
- 非法标识符举例：123abc,-salary,#abc
- 可用中文命名，但一般不建议，也不建议用拼音
关键字
-
（或称保留字）被java语言赋予了特殊含义，用作专门用途的字符串。
-
关键字中所有字母都为小写。关键字不能用作变量名，方法名，类名，包名和参数。
-
Java一共包含51个关键字
- final关键字：final是java中的一个关键字，意思为“恒定不变”。 java中final数据具体有两个含义：对于基本数据类型，表示永不改变的编译时常量；对于普通对象，表示该引用恒定不变，不能指向另外一个对象，但是该对象本身是可以进行修改的。
标识符和关键字的区别
1.主体不同
关键字属于保留字，是整个语言范围内预先保留的标识符。 一般标识符是用户编程时使用的名字，用于给变量、常量、函数、语句块等命名，以建立起名称与使用之间的关系。
2.特点不同
关键字不能声明与关键字同名的标识符。 一般标识符由字母和数字以及其它字符构成。
数据类型
类型语言和弱类型语言
- 强类型语言
要求变量的使用要严格符合规定，所有的变量都必须先定义后才能使用。（比如：Java、C/C++、.NET)
好处：安全性高，声明变量的语法较简单
弊端：速度慢（相对于弱类型语言） - 弱类型语言
（比如：vb、php、JavaScript）
基本数据类型
Java的基本数据类型分为两大类：boolean类型和数值类型。数值类型又分为：整数类型和浮点类型。整数类型里的字符类型也可被单独对待。整数类型里的字符类型也可被单独对待。因此常把Java里的基本数据类型分为4类
变量与常量
与所有的程序设计语言一样，Java也使用变量来存储值。常量就是值不变的变量。
变量
变量就是可以变化的量。
声明变量：
- Java是一种强类型语言，每个变量都必须声明类型（type）。
- Java变量是程序中最基本的存储单元，其要素包括变量名，变量类型和作用域。
例：
type varName [=value] [{,varName[=value]}] ;
//数据类型 变量名 = 值 ; 可以使用逗号隔开来声明多个同类型变量
double salary;
int vacationDays;
注意：
-
每个变量都有类型，类型可以是基本类型，也可是引用类型
-
变量名必须是合法的标识符。第一个字符不能是数字。不能使用Java关键字作为变量名
-
变量声明是一条完整的语句，所有的Java语句都以分号结束，因此每一个声明都必须以分号结束
-
Java中的“字母”“数字”和“货币符号”的范围更大。字母是指一种语言中表示字母的任何Unicode字符
-
可在一行中声明多个变量(不提倡，分别声明每一个变量可以提高程序的可读性）：
int i,j;//both are integers
初始化变量
声明一个变量后，必须用赋值语句显示的初始化变量。避免使用未初始化的变量的值。
int a;
a = 13;
--------------------------------------------------
int a = 13
- Java中可以将声明放在代码的任何地方（不过还是建议变量的声明要尽可能靠近第一次使用这个变量的地方）
常量
在Java中，可以用关键字final指示常量
关键字final表示这个变量只能被赋值一次，赋值后，就不能再更改了，若在常量定义时初始化后强行赋值，数据库会跳出错误信息，并拒绝接受这一个新的值。在给常量取名时，一般都采用大写字符（主要是与变量进行区分）
注意
- 类常量的定义位于main方法之外。这样同一类的其他方法也可以使用这个常量
- 若一个常量被声明为public，那么其他类的方法也可使用该常量
- 必须在常量声明时对其进行初始化
- 关键字final不仅可以用来修饰基本数据类型的常量，还可用来修饰对象的引用或者方法
- 当一个数组对象被关键字final设置为常量时，它只能够恒定的指向一个数组对象，无法将其改变指向另外一个对象，也无法更改数组中的值
运算符
运算符用于连接值，Java提供了一组丰富的算术和逻辑运算符以及数学函数。
算术运算符
在Java中，使用+、 - 、* 、 / 来分别表示加减乘除运算，++自加、--自减
- “ / ”表示整数除法，即参与 /运算的两个操作数都为整数，若操作数有一个是浮点数或者两个都是，则表示的是浮点除法，计算结果就是自然除法的结果
- “ % ”表示整数的求余操作
- 注意：整数被0整除将产生一个异常，而浮点数被0或0.0整除将会得到一个无穷大或NaN结果
- “ + ”还可以作为字符串的连接运算符；“ - ”还可以作为求负的运算符
数学函数与常量
Java中没有提供其他更复杂的运算符，若需要完成乘方、开方等运算，则可借助java.lang.Math类的工具方法完成复杂的数学运算。
Math类下包含了丰富的静态方法，用于完成各种复杂的数学运算
Math还提供了两个常量来表示π和e常量最接近的近似值：
Math.PI
Math.E
数值类型之间的转换
经常需要将一种数值类型转换为另一种数值类型。如图：
图中的实线箭头表示无丢失的转换；虚线箭头表示可能有精度损失的转换
当用一个二元运算符连接两个值时（例：a+b，a为整数，b为浮点数），先要将两个操作数转换为同一种类型，然后再进行计算
- 若两个操作数中有一个为double类型，另一个操作数就会转换为double类型
- 否则，若其中一个操作数是float类型，另一个操作数就会转换为float类型
- 否则，若其中一个操作数是long类型，另一个操作数就会转换为long类型
- 否则，两个操作数都将被转换为int类型
强制类型转换
若想把图3-1中箭头右边的类型转换为左边的类型，则必须进行强制类型转换。
强制类型转换的语法格式是在()中指定想要转换的目标类型，后面紧跟待转换的变量名：
(targetType) value
------------------------------------------------------------------------------------
double x = 9.997;
int nx = (int) x;
当进行强制类型转换时，是有可能损失信息的。
赋值
赋值运算符用于为变量指定变量值。赋值表达式是有值的，赋值表达式的值就是右边被赋的值。
- 将一个直接量值赋给变量。
var pi = 3.14; //为变量pi赋值3.14 - 将一个变量的值赋给另一个变量
var str2 = str; //将变量str的值赋给str2 - 赋值表达式支持连续赋值，通过使用多个赋值运算符，可一次为多个变量赋值
int a;
int b;
//为a,b赋值，两个变量的值为2
a = b = 2;
- 将表达式的值赋给变量
var d1 = 12.13; var d2 = d1 + 3; //将表达式的值赋给都 - 赋值运算符还可以和其他运算符结合
自增和自减运算符
前缀是先完成加一或减一，后缀是会使用变量原来的值
例：
int m = 7;
int n = 7;
int a = 2 * ++m;//a为16，m为8
int b = 2 * n--; //b为14，n为8
关系和boolean运算符
比较运算符用于判断两个变量或常量的大小，比较运算的结果是一个布尔值(即true或false)
逻辑运算符用于操作两个布尔型的变量或常量
比较运算符：==、!=、<、>、<=、>=
逻辑运算符：&&与、&不短路与、||或、|不短路或、!非、^异或
&&和||是按照“短路”方法来求值的：
若第一个操作数已经能够确定表达式的值，第二个操作数就不必计算
条件运算符/三目运算符
Java提供了? :运算符，可根据一个布尔表达式选择一个值。若条件(condition)为真true，表达式condition ? expression1 : expression2就计算为第一个表达式的值,否则为第二个表达式的值
例：
(expresssion) ? if-true-statement : if-false-statement;
-----------------------------------------------------------------------------------
x < y ? x : y
会返回x和y中较小的一个
switch运算符
当需要在两个以上的值中做出选择时，可使用switch表达式
String seasonName = switch (seasonCode)
{
case 0 -> "Spring";
case 1 -> "Summer";
case 2 -> "Fall";
case 3 -> "Winter";
default -> "???";
};
case标签还可以是字符串或者枚举类型常量
与所有表达式类似，switch表达式也有一个值。注意各个分支中箭头->放在值前面
注意
- 使用整数或者String操作数的switch表达式必须有一个default，因为不论操作数值是什么，这个表达式都必须生成一个值
- 如果操作数为null，会抛出一个
NullPointerException
位运算符
处理整型类型时，还有一些运算符可以直接处理组成整数的各个位。这意味着可以使用掩码技术得到一个数中的各个位。一般来说，位运算符只能操作整数类型的变量或值。Java支持的位运算符有以下七个：
& :按位与。当两位同时为1时才返回1
| :按位或。只要有一位为1即可返回1
~:按位非。单目运算符，将操作数的每个位(包括符号位)全部取反
^ :按位异或。当两位相同时返回0，不同时返回1
<< :左移运算符
>> :右移运算符。会用符号位填充高位
>>> :无符号右移运算符。会用0填充高位
注意
- 应用在布尔值上时，&和 | 也会得到一个布尔值。但&和 | 运算符不采用“短路”来求值，即计算结果前，两个操作数都需要计算
- 不存在<<<运算符
括号与运算符级别
Java中大部分运算符是从左向右结合的，同一级别的运算符按从左往右的次序进行计算，右结合运算除外。只有单目运算符、赋值运算符、三目运算符是从右向左结合的。
注意
- Java不使用逗号运算符
- 源代码就是一份文档，其可读性很重要
- 不要把表达式写的太复杂，可分几步完成
- 不要过度依赖运算符优先级来控制表达式的执行顺序，可用()来控制
字符串
Java字符串就是Unicode字符序列。
Java没有内置的字符串类型，字符串是 Java 一个内置的类
字符型：
只能装单个字符(英文、中文等)，且单个字符要放在单引号里。
char: 2个字节(16位置)
- 字符型的注意点
- 单引号里放普通字符
- 单引号里放特殊的转义字符
- 用字符的Unicode编号。十六进制。
子字符串
String类的substring方法可以从一个较大的字符串提取出一个子字符串
如：
String greeting = "Hello";
String s = greeting.substring(0, 3);
会创建一个由字符"Hel"组成的字符串
与C类似，Java字符串中的代码单元和码点从0开始计数
substring() 方法返回字符串的子字符串。可以理解为字符串切片。
语法
public String substring(int beginIndex)
或
public String substring(int beginIndex, int endIndex)
参数
beginIndex -- 起始索引（包括）。
endIndex -- 结束索引（不包括）。
注意：这两个参数都为int类型
返回值
子字符串。
例：
public class Test {
public static void main(String args[]) {
String Str = new String("www.zicehello233");
System.out.print("返回值 :" );
System.out.println(Str.substring(4) );
System.out.print("返回值 :" );
System.out.println(Str.substring(4, 13) );
}
}
以上程序执行结果为：
返回值 :zicehello233
返回值 :zicehello
substring(start,end),可以有不同的说明，即start可以是要返回的长度，end是所要去掉的多少个字符(从首位开始)。（end-strat)
如：子串"Hel"的程度为3-0=3
拼接
- 法一：**Java允许使用 " + " 来连接两个字符串
String t = "abc";
t = t + "d";
System.out.println(t);
输出：
abcd
- 法二：使用concat
concat是String自带的一个拼接方法
String t = "abc";
t = t.concat("d");
System.out.println(t);
输出：
abcd
- 法三：使用静态join方法：
若需要把多个字符放在一起，用一个界定符分隔，可使用静态join方法：
String t = "abc";
t = StringUtils.join(t, "d");
System.out.println(t.toString());
输出：
abcd
字符串不可变
什么是不可变对象：一旦对象被创建并初始化后，内部的状态数据就会保持不变。
字符串对象在 Java 中是不可变的。不可变只是表示无法更改或更改某些内容。String类没有提供任何方法来修改字符串中的某个字符。
检测字符串是否相等
- 法一：使用equals方法检测两个字符串是否相等：
s.equals(t)
若字符串s与字符串t相等，则返回true；反之，返回false。
s与t可以是字符串变量，也可以是字符串字面量。如该表达式"Hello".equals(greeting)是合法的。
注：字符串字面量（stringliteral）是指双引号引住的一系列字符，双引号中可以没有字符，可以只有一个字符，也可以有很多个字符。
#include <stdio.h>
int main(void)
{
int a = 10; // 10为int类型字面量
char a[] = {"Hello world!"} // Hello world 为字符串形式字面量
return 0;
}
- 法二：使用
equalsIgnoreCase方法来检测不区分大小写的两个字符串是否相等
"hello".equalsIgnoreCase("Hello")
注意：判断字符串是否相等不要使用＝＝运算符，该运算符只能确定两个字符串是否存放在同一位置上。当然，若字符串存放在同一个位置上，它们必然相等。但也完全有可能将多个相等的字符串副本存放在不同的位置上。
空串与Null串
空串""是长度为0的字符串,也是一个Java对象，有自己的串长度（0）和内容（空）。
可以调用以下代码来检测一个字符串是否为空：
if(str.length()==0)
或
if(str.equals(""))
String变量还可存放一个特殊的值：null，表示目前没有任何对象与该变量相关联。
想检查一个字符串是否为null可使用以下代码：
if(str==null)
要想检查一个字符串既不是null也不是空串，可使用以下代码：
if(str!=null&&str.length()!=0)
输入与输出
1.输出
可用:
System.out.println();
或
System.out.print();
或
System.out.printf();
将输出发送到标准输出（屏幕）。
System 是一个类
out 是一个public static字段：它接受输出数据。
println()，print()和printf()之间的区别:
-
print() - 它在引号内打印字符串。
-
println() - 它在引号内打印字符串，类似于print()方法。然后光标移动到下一行的开头。
-
printf() - Tt提供字符串格式化（类似于C / C ++编程中的printf）。
例1：print()和println()
class Output {
public static void main(String[] args) {
System.out.println("1. println ");
System.out.println("2. println ");
System.out.print("1. print ");
System.out.print("2. print");
}
}
输出：
1. println
2. println
1. print 2. print
例2：打印变量和字面量:
class Variables {
public static void main(String[] args) {
Double number = -10.6;
System.out.println(5);
System.out.println(number);
}
}
运行该程序时，输出为：
5
-10.6
从上面可以看到没有使用引号。这是为了显示整数、变量等，因而没有使用引号。
例3：打印串联的字符串：
class PrintVariables {
public static void main(String[] args) {
Double number = -10.6;
System.out.println("I am " + "awesome.");
System.out.println("Number = " + number);
}
}
输出：
I am awesome.
Number = -10.6
在上面的示例中，请注意以下行：
System.out.println("I am " + "awesome.");
在这里，我们使用了+运算符来连接（串联）两个字符串："I am " 和 "awesome."。
System.out.println("Number = " + number);
首先求变量number的值。 然后将该值连接到字符串：“ Number =”。
2.输出
使用Scanner类的对象从用户那里获取输入。
为了使用的对象Scanner，需要导入java.util.Scanner包
import java.util.Scanner;
然后，需要创建Scanner类对象。就可以使用该对象从用户那里获取输入
//创建Scanner对象
Scanner input = new Scanner(System.in);
//接受用户的输入
int number = input.nextInt();
例：从用户获取整数输入
import java.util.Scanner;
class Input {
public static void main(String[] args) {
Scanner input = new Scanner(System.in);
System.out.print("输入一个整数: ");
int number = input.nextInt();
System.out.println("您输入 " + number);
//关闭scanner对象
input.close();
}
}
输出：
输入一个整数: 23
您输入 23
在以上示例中，我们创建了一个名为Scanner类的input对象。 然后，我们调用Scanner类的nextInt()方法以从用户获取整数输入。
同样，我们也可使用nextLong()，nextFloat()，nextDouble()和next()方法来分别从用户获取long，float，double和string输入。
注意：我们已使用close()方法关闭对象。建议一旦输入，就关闭scanner对象。
例：获取浮点，双精度和字符串输入
import java.util.Scanner;
class Input {
public static void main(String[] args) {
Scanner input = new Scanner(System.in);
//获取float输入
System.out.print("Enter float: ");
float myFloat = input.nextFloat();
System.out.println("Float entered = " + myFloat);
//获取double输入
System.out.print("Enter double: ");
double myDouble = input.nextDouble();
System.out.println("Double entered = " + myDouble);
//获取字符串输入
System.out.print("Enter text: ");
String myString = input.next();
System.out.println("Text entered = " + myString);
}
}
输出：
Enter float: 2.343
Float entered = 2.343
Enter double: -23.4
Double entered = -23.4
Enter text: Hey!
Text entered = Hey!
控制流程
Java 的流程控制语句与 C++ 是基本相同的。
1.条件语句
public class Test {
public static void main(String[] args) {
if ( /* 判断条件 */ ) {
// 条件成立时执行这里面的代码
} else {
// 条件不成立时执行这里面的代码
}
}
}
2.循环语句
想同样的操作执行多次，就需要使用循环结构。
Java中有三种主要的循环结构：
- while 循环
- while是最基本的循环，它的结构为：
while( 布尔表达式 ) {
//循环内容
}
只要布尔表达式为 true，循环就会一直执行下去。
- do…while 循环
- 对于 while 语句而言，如果不满足条件，则不能进入循环。但有时候我们需要即使不满足条件，也至少执行一次。
do…while 循环和 while 循环相似，不同的是，do…while 循环至少会执行一次。
do {
//代码语句
}while(布尔表达式);
注意：布尔表达式在循环体的后面，即语句块在检测布尔表达式之前已经执行了。 若布尔表达式的值为 true，则语句块一直执行，直到布尔表达式的值为 false。
- for 循环
- for 循环，使一些循环结构变得更加简单。for循环执行的次数是在执行前就确定的。语法格式如下：
for(初始化; 布尔表达式; 更新) {
//代码语句
}
关于 for 循环：
最先执行初始化步骤。可以声明一种类型，但可初始化一个或多个循环控制变量，也可以是空语句。
然后，检测布尔表达式的值。如果为 true，循环体被执行。如果为false，循环终止，开始执行循环体后面的语句。
执行一次循环后，更新循环控制变量。
再次检测布尔表达式。循环执行上面的过程。
- 增强 for 循环
增强 for 循环语法格式如下:
for(声明语句 : 表达式)
{
//代码句子
}
声明语句：声明新的局部变量，该变量的类型必须和数组元素的类型匹配。其作用域限定在循环语句块，其值与此时数组元素的值相等。
表达式：表达式是要访问的数组名，或者是返回值为数组的方法。
3.多重选择：switch语句
switch case 语句判断一个变量与一系列值中某个值是否相等，每个值被称为一个分支。
语法
switch case 语句语法格式如下：
switch(expression){
case value :
//语句
break; //可选
case value :
//语句
break; //可选
//你可以有任意数量的case语句
default : //可选
//语句
}
- switch case 语句有如下规则：
- switch 语句中的变量类型可以是：byte、short、int 或者 char。从 Java SE 7 开始，switch 支持字符串 String 类型了，同时 case 标签必须为字符串常量或字面量。
- switch 语句可以拥有多个 case 语句。每个 case 后面跟一个要比较的值和冒号。
- case 语句中的值的数据类型必须与变量的数据类型相同，而且只能是常量或者字面常量。
- 当变量的值与 case 语句的值相等时，那么 case 语句之后的语句开始执行，直到 break 语句出现才会跳出 switch 语句。
- 当遇到 break 语句时，switch 语句终止。程序跳转到 switch 语句后面的语句执行。case 语句不必须要包含 break 语句。如果没有 break 语句出现，程序会继续执行下一条 case 语句，直到出现 break 语句。
- switch 语句可以包含一个 default 分支，该分支一般是 switch 语句的最后一个分支（可以在任何位置，但建议在最后一个）。default 在没有 case 语句的值和变量值相等的时候执行。default 分支不需要 break 语句。
- switch case 执行时，一定会先进行匹配，匹配成功返回当前 case 的值，再根据是否有 break，判断是否继续输出，或是跳出判断。
4.中断控制流程的语句
- break 关键字
break 主要用在循环语句或者 switch 语句中，用来跳出整个语句块。
break 跳出最里层的循环，并且继续执行该循环下面的语句。
语法
break ，就是循环结构中的一条语句：
break;
- continue 关键字
continue 适用于任何循环控制结构中。作用是让程序立刻跳转到下一次循环的迭代。
在 for 循环中，continue 语句使程序立即跳转到更新语句。
在 while 或者 do…while 循环中，程序立即跳转到布尔表达式的判断语句。
语法
continue 就是循环体中一条语句：
continue;
数组
数组存储相同类型值的序列。
数组是一种数据结构，用来存储同一类型值的集合。
语法格式为:数据类型[] 变量名 = new 数据类型[数组大小]
例：
int[] ary = new int[10];
声明数组
必须声明数组变量，才能在程序中使用数组。
声明数组变量的语法：
dataType[] arrayRefVar; // 首选的方法
或
dataType arrayRefVar[]; // 效果相同，但不是首选方法
注意: 建议使用 dataType[] arrayRefVar 的声明风格声明数组变量。
以下是这两种语法的代码示例：
double[] myList; // 首选的方法
或
double myList[];
处理数组
数组的元素类型和数组的大小都是确定的，所以当处理数组元素时候，我们通常使用基本循环或者 for each 循环。
for each循环
for each 循环或者说加强型循环，它能在不使用下标的情况下遍历数组。
语法格式：
for(type element: array){
System.out.println(element);
}
面向对象程序设计概述
面向对象程序设计（Object Oriented Programming，OOP）是一种计算机编程架构。OOP的一条基本原则是计算机程序由单个能够起到子程序作用的单元或对象组合而成。OOP达到了软件工程的三个主要目标：重用性、灵活性和扩展性。OOP=对象+类+继承+多态+消息，其中核心概念是类和对象。
面向对象程序设计方法是尽可能模拟人类的思维方式，使得软件的开发方法与过程尽可能接近人类认识世界、解决现实问题的方法和过程，也即使得描述问题的问题空间与问题的解决方案空间在结构上尽可能一致，把客观世界中的实体抽象为问题域中的对象。
面向对象程序设计以对象为核心，该方法认为程序由一系列对象组成。类是对现实世界的抽象，包括表示静态属性的数据和对数据的操作，对象是类的实例化。对象间通过消息传递相互通信，来模拟现实世界中不同实体间的联系。在面向对象的程序设计中，对象是组成程序的基本模块。
Java是面向对象的，须熟悉OOP才能很好的运用Java。
类
类是面向对象语言的程序设计中的概念，是面向对象编程的基础。
类的实质是一种引用数据类型，类似于 byte、short、int（char）、long、float、double 等基本数据类型，不同的是它是一种复杂的数据类型。因为它的本质是数据类型，而不是数据，所以不存在于内存中，不能被直接操作，只有被实例化为对象时，才会变得可操作。
类指定了如何构造对象，由一个类构造对象的过程称为创造这个类的一个实例。
用Java编写的所有代码都在某个类中。标准Java库提供了几千个类可用于各种目的，但我们仍需要创造一些自己的类，来描述我们的应用相应问题领域中的对象。
类的三大特性
- 封装性将数据和操作封装为一个有机的整体，由于类中私有成员都是隐藏的，只向外部提供有限的接口，所以能够保证内部的高内聚性和与外部的低耦合性。用者不必了解具体的实现细节，而只是要通过外部接口，以特定的访问权限来使用类的成员，能够增强安全性和简化编程。
- 继承性更符合认知规律，使程序更易于理解，同时节省不必要的重复代码。
- 多态性是指同一操作作用于不同对象，可以有不同的解释，产生不同的执行结果。在运行时，可以通过指向父类（基类）的指针，来调用实现子类（派生类）中的方法。
对象
类表示一个共性的产物，是一个综合的特征，对象，是一个个性的产物，是一个个体的特征。 （饼干模具与饼干）类必须通过对象才可以使用，对象的所有操作都在类中定义。
需弄清楚的对象的三个主要特性：
- 对象的行为：可以对这个对象做哪些操作，或可对该对象应用哪些方法
- 对象的状态：调用那些方法时，对象将如何响应
- 对象的标识：如何区分可能有相同行为和状态的不同对象
同一个类的所有实例对象都有一种家族相似性，它们都支持相同的行为。
一个对象的行为由所能调用的方法来定义。
每个对象都会保存着描述当前状况的信息，这就是对象的状态：
- 对象的状态可能会随着时间而发生改变，但这种改变不是自发的
- 对象状态的改变必然是调用方法的结果（若不经过方法调用就可以改变，这说明该对象的封装性被破坏了。
类之间的关系
类之间最常见的关系有：
- 依赖（“uses-a")
- 聚合（”has-a")
- 继承（“is-a”）