肖sir__Java API Java类和对象13
1.1 面向对象概述
什么是对象？
所谓对象就是真实世界中的事物，对象与事物一一对应，也就是说现实世界中每一个
事物都是一个对象。
比如：
物：张三的宠物狗旺财。张三是一个对象，旺财也是一个对象。
事：李四在多测师学Java开发。李四是对象，多测师是对象，Java开发也是对象
对象的特点：
对象具有属性和行为。
//比如张三的属性：有姓名，年龄，性别。行为：养宠物
对象具有变化的状态。
//比如张三的年龄，身高，体重都会随着时间而发生变化
对象具有唯一性。
//比如张三这个人在现实生活中就是唯一的
对象都是某个类别的实例。//比如张三是人类的实例
=================================
1.2 面向对象概述
Java中的对象：
Java是面向对象的编程语言，对象就是面向对象程序设计的核心。
在Java语言中，一切皆对象。Java中使用类抽象地把现实世界中某一类别的事物进行
定义描述。而Java中的对象就是类的一个实例。一个Java中的对象代表了某个具体的
事物。
例如，在真实世界的学校里，会有学生和老师。学生有学号、姓名、所在班级等属性。学生还有学习、提问、吃饭和走路等行为。学生只是学生这个类别抽象的描述，这个抽象的描述称为“类”。在学校里的是学生个体，即张同学、李同学等，这些具体的个体称为“对象”，“对象”也称为“实例”。
面向对象，简称 OO（Object Oriented）
面向对象编程，简称OOP（Object Oriented Programming）
=================================
2.1 类和对象
Java中的类：
类描述了一组有相同特性（属性）和相同行为（方法）的一组对象的集合。
类是构造面向对象程序的基本单位，是抽取了同类对象的共同属性和方法所形成的对象或实体的“模板”。而对象是现实世界中实体的描述，对象要创建才存在，有了对象才能对对象进行操作。类是对象的模板，对象是类的实例。
比如：
每个人都有身高、体重、年龄、血型等属性。人会劳动、会直立行走、会用自己的头脑去创造工具等方法。人之所以能区别于其他类型的动物，是因为每个人都具有“人类”这个群体的属性与方法。“人类”只是一个抽象的概念，它仅仅是一个概念，是不存在的实体！但是所有具备“人类”这个群体的属性与方法的对象都叫人！这个对象“人” 是实际存在的实体！每个人都是“人”这个群体的一个对象
=================================
2.2 类和对象
Java中类的定义语法：
[public][abstract|final]class<class_name>[extends<class_name>][implements
<interface_name>] {
// 定义成员变量（属性）
[public|protected|private][static][final]<type><variable_name>；
…
// 定义成员方法（行为）
[public|private|protected][static]<void|return_type><method_name>([para
mList]) {
// 方法体
} …
}
说明：中括号“[]”中的部分表示可以省略，竖线“|”表示“或关系”，例如 abstract|final，说明可
以使用 abstract 或 final 关键字，但是两个关键字不能同时出现。
=================================
2.3 类和对象
定义类中各关键字的描述如下：
public：访问控制修饰符。public修饰，则可以被其他类和程序访问。
abstract：如果类被 abstract 修饰，则该类为抽象类。
final：如果类被 final 修饰，则不允许被继承。
class：声明类的关键字。
class_name：类的名称。
extends：表示继承其他类。
implements：表示实现某些接口。
property_type：表示成员变量的类型。
property：表示成员变量名称。
function()：表示成员方法名称。
=================================
2.4 类和对象
Java中类定义成员变量的语法如下：
[public|protected|private][static][final]<type><variable_name>；
各参数的含义如下：
public、protected、private：用于表示成员变量的访问权限。
static：表示该成员变量为类变量，也称为静态变量。
final：表示将该成员变量声明为常量，其值无法更改。
type：表示变量的类型。
variable_name：表示变量名称。
=================================
2.5 类和对象
Java中类定义成员方法的语法如下：
[public|private|protected][fainal][static]<void|return_type><method_name>([
paramList]) {
// 方法体
}
各参数的含义如下：
public、private、protected：表示成员方法的访问权限。
static：表示该成员方法为静态方法。
final：表示该成员方法不能被重写或重载。
abstract：表示该成员方法为抽象方法，并且所属类必须为抽象类。
method_name：方法名称。
paramList：入参数列表
=================================
2.6 类和对象
Java中类的定义实例：
定义一个人的类，人的属性有姓名，年龄。行为有说话等。
使用Java类来定义描述，如下：
public class Person {
private String name; // 姓名（属性）
private int age; // 年龄（属性）
// 定义说话的方法（行为）
public void tell() {
System.out.println(name+"今年"+age+"岁！");
}
}
=================================
2.7 类和对象
Java类中的构造方法：
构造方法是类的一种特殊方法，用来初始化类的一个新的对象，每个类都有构造方法。如果没有显式地为类定义构造方法，Java编译器将会为该类提供一个默认构造方法。在创建对象的时候，至少要调用一个构造方法。一个类可以有多个构造方法。
Java构造方法有以下特点：
1，方法名必须与类名相同
2，可以有 0 个、1 个或多个参数
3，没有任何返回值，包括 void
4，默认返回类型就是对象类型本身
5，只能与 new 运算符结合使用
说明：构造方法可以使用private修饰，如果类中只有一个构造方法，并且使用private修饰，则在外部无法使用该类创建该类的实例对象
=================================
2.8 类和对象
this关键字：
this可用于任何实例方法内指向当前对象，也可指向对其调用当前方法的对象。
比如：this.属性名；this.方法名；this(); // this调用构造方法
注意：this( ) 不能在普通方法中使用，只能写在构造方法中。在构造方法中使用时，
必须是第一条语句。
this.属性名的使用场景：
大部分时候，普通方法访问其他方法、成员变量时无须使用 this 前缀，但如果方法里有个局部变量和成员变量同名，但程序又需要在该方法里访问这个被覆盖的成员
变量，则必须使用 this 前缀。
比如：在构造方法中使用this关键字：
public Person(String name,int age){
this.name = name;
this.age = age;
}
=================================
2.9 类和对象
对象的创建：
对象是对类的实例化。对象具有状态和行为，变量用来表明对象的状态，方法表明
对象所具有的行为。
在Java中，使用关键字new来创建一个新的对象。使用new关键词时会自动调用类
中的构造方法创建对象。
创建对象需要以下三步：
声明：声明一个对象，包括对象名称和对象类型。
实例化：使用关键字new来创建一个对象。
初始化：使用new创建对象时，会调用构造方法初始化对象。
例如：
Person persion = new Person("张三",20);
=================================
2.1.0 类和对象
访问对象的变量和方法：
在Java中对象被创建后则可以使用该对象来访问对象中的变量和方法。
语法如下：
对象名. 成员变量
// 访问对象的属性
对象名.成员方法名() // 访问对象的方法
例如：
Person persion = new Person("张三",20);
persion.tell(); // 访问对象的方法
说明：如果一个对象要被使用，则对象必须被实例化，如果一个对象没有被实例化
而直接调用了对象中的属性或方法则会导致程序异常
3.1 访问控制修饰符
在Java中，可以使用访问控制修饰符来保护对类、变量、方法和构造方法的访问。
类的访问控制符只能是空或者public，方法和属性的访问控制符有 4 个，分别是 pub
lic、private、protected和default ，其中default即默认，什么也不写。
访问控制修饰符的权限如下：
3.2 访问控制修饰符
默认访问修饰符（不使用任何关键字）
使用默认访问修饰符声明的变量和方法，对同一个包内的类是可见的。
接口里的变量都隐式声明为 public static final,而接口里的方法默认情况下访问权限
为 public。
如下例所示，变量和方法的声明可以不使用任何修饰符：
String version = "1.5.1";
boolean processOrder() {
return true;
}
3.3 访问控制修饰符
私有访问修饰符-private
被声明为private的方法、变量和构造方法只能被所属类访问，并且类和接口不能声明
为private。声明为私有访问类型的变量只能通过类中公共的方法被外部类访问。
例如下面的类使用了私有访问修饰符：
public class Logger {
private String format;
public String getFormat() {
return this.format;
}
public void setFormat(String format) {
this.format = format;
}
}
3.4 访问控制修饰符
公有访问修饰符-public
被声明为 public 的类、方法、构造方法和接口能够被任何其他类访问。
如果几个相互访问的 public 类分布在不同的包中，则需要导入相应 public 类所在的
包。
由于类的继承性，类所有的公有方法和变量都能被其子类继承。
以下函数使用了公有访问控制：
public static void main(String[] arguments) {
// ...
}
说明：
Java 程序的 main() 方法必须设置成公有的，否则，Java 解释器将不能运行该类。
3.5 访问控制修饰符
受保护的访问修饰符-protected
protected两种场景说明：
子类与基类在同一包中：被声明为 protected 的变量、方法和构造器能被同一个包中的任何其他类访问；
子类与基类不在同一包中：那么在子类中可以访问其从基类继承而来的 protected 方法，而不能访问基类实例的protected方法。
protected 可以修饰构造方法，方法成员，不能修饰类（内部类除外）。
接口及接口的成员变量和成员方法不能声明为 protected。
子类能访问 protected 修饰符声明的方法和变量，这样就能保护不相关的类使用这些
方法和变量
3.6 访问控制修饰符
访问控制修饰符和继承：
父类中声明为 public 的方法在子类中也必须为 public。
父类中声明为 protected 的方法在子类中要么声明为 protected，要么声明为
public，不能声明为 private。
父类中声明为 private 的方法，不能够被继承。
4.1 非访问控制修饰符
Java中非访问修饰符：
static 修饰符，用来修饰类方法和类变量。
final 修饰符，用来修饰类、方法和变量，final 修饰的类不能够被继承，修饰的方法不能被继承类重新定义，修饰的变量为常量，是不可修改的。
abstract 修饰符，用来创建抽象类和抽象方法。
synchronized 和 volatile 修饰符，主要用于线程的编程
4.2 非访问控制修饰符
static 修饰符
静态变量：
static 关键字用来声明独立于对象的静态变量，无论一个类实例化多少对象，它的静
态变量只有一份拷贝。
静态变量也被称为类变量。局部变量不能被声明为 static 变量。
静态方法：
static 关键字用来声明独立于对象的静态方法。静态方法不能使用类的非静态变量。
静态方法从参数列表得到数据，然后计算这些数据。
对类变量和方法的访问可以直接使用 classname.variablename 和 classname.meth
odname 的方式访问
4.3 非访问控制修饰符
final 修饰符
final 变量：
final 表示"最后的、最终的"含义，变量一旦赋值后，不能被重新赋值。
被 final 修饰的实例变量必须显式指定初始值。
final 修饰符通常和 static 修饰符一起使用来创建类常量
final 方法：
父类中的 final 方法可以被子类继承，但是不能被子类重写。
声明 final 方法的主要目的是防止该方法的内容被修改。
final 类：
final 类不能被继承，没有类能够继承 final 类的任何特性。
4.4 非访问控制修饰符
abstract 修饰符，可以修饰类和修饰方法，
使用abstract修饰的类---抽象类：
抽象类不能用来实例化对象，声明抽象类的唯一目的是为了将来对该类进行扩充。
一个类不能同时被 abstract 和 final 修饰。如果一个类包含抽象方法，那么该类一定
要声明为抽象类，否则将出现编译错误。
抽象类可以包含抽象方法和非抽象方法。
使用abstract修饰的方法---抽象方法（是一种没有任何实现的方法）
抽象方法不能被声明成 final 和 static。
任何继承抽象类的子类必须实现父类的所有抽象方法，除非该子类也是抽象类。
如果一个类包含若干个抽象方法，那么该类必须声明为抽象类。抽象类可以不包含抽
象方法。
抽象方法的声明以分号结尾，例如：public abstract sample();
其他修饰符
synchronized 修饰符：
synchronized 关键字声明的方法同一时间只能被一个线程访问。
transient 修饰符：
该修饰符包含在定义变量的语句中，用来预处理类和变量的数据类型
volatile 修饰符：
volatile 修饰的成员变量在每次被线程访问时，都强制从共享内存中重新读取该成员
变量的值。
而且，当成员变量发生变化时，会强制线程将变化值回写到共享内存。
这样在任何时刻，两个不同的线程总是看到某个成员变量的同一个值。
5.1 包的定义和导入包
包的定义package：
Java 引入了包（package）机制，提供了类的多层命名空间，用于解决类的命名冲突、
类文件管理等问题。
包的 3 个作用如下：
1，区分相同名称的类。
2，能够较好地管理大量的类。
3，控制访问范围。
Java 中使用 package 语句定义包，package 语句应该放在源文件的第一行，在每个
源文件中只能有一个包定义语句，并且 package 语句适用于所有类型（类、接口、
枚举和注释）的文件。定义包语法格式如下：
5.2 包的定义和导入包
包语法格式如下：
package 包名;
Java 包的命名规则如下：
包名全部由小写字母（多个单词也全部小写）。
如果包名包含多个层次，每个层次用“.”分割。
包名一般由倒置的域名开头，比如 com.baidu，不要有 www。
自定义包不能 java 开头。
例如：com.dcs;
5.3 包的定义和导入包
导入包：
Java 引入了 import 关键字，import 可以向Java文件中导入指定包层次下的某个类或全部类。import 语句位于 package 语句之后，类定义之前。一个 Java 源文件只能包含一个 package 语句，但可以包含多个 import 语句。
使用 import 导入单个类的语法格式如下：
import 包名.类名;
例如：
import com.dcs.Person;
5.4 包的定义和导入包
导入包：
Java导入某个包下面所有的类。
使用 import 导入某个包所有类的语法格式如下：
import 包名.*;
例如：
import com.dcs.*;
说明：”*“代表一个包下面的所有类。使用星号（
*）可能会增加编译时间，特别是
引入多个大包时，所以明确的导入你想要用到的类可以减少编译世界。
5.5 包的定义和导入包
导入包：
在一些时候使用第三方包时，两个包种有相同名称的类，这个时候就需要通过类全名
来指定具体的类了。
使用类全名指定类，比如：
com.dcs.Person person = new com.dcs.Person();
说明：Java 默认为所有源文件导入 java.lang 包下的所有类，因此前面在 Java 程序
中使用 String、System 类时都无须使用 import 语句来导入这些类。
课后练习题
课后练习：
1，定义一个学生的类，
学生的属性：姓名，年龄，性别，身高，体重
定义一个体育项目类
体育项目类包含，打篮球和举重2个方法
学校要求
身高超过170cm的学生要打篮球，
所有学生中体重最重的人要举重
再定义一个主类，主类中包含身高比较的方法，体重比较的方法。
创建三个学生来测试
2.9 类和对象
