面向对象（上）
1.1 面向对象的思想
1 封装性
封装是面向对象的核心思想，它有两层含义，第一层含义是指把对象的属性和行为看成是一个密不可分的整体，将这两者“封装”在一起（即封装在对象中）；另外一层含义指“信息隐藏”，将不想让外界知道的信息隐藏起来。
2 继承性
继承性主要描述的是类与类之间的关系，通过继承，可以在原有类的基础上，对原有类的功能进行扩展。
3 多态性
多态性是指在一个类中定义的属性和方法被其他类继承后，它们可以具有不同的数据类型或表现出不同的行为，这使得同一个属性和方法在不同的类中具有不同的语义。
2 类与对象
2.1 类的定义
在面向对象的思想中最核心的就是对象，创建对象的前提是需要定义一个类，类是Java中一个重要的引用数据类型，也是组成Java程序的基本要素，所有的Java程序都是基于类的。
类是对象的抽象，用于描述一组对象的共同特征和行为。类中可以定义成员变量和成员方法，其中，成员变量用于描述对象的特征，成员变量也被称作对象的属性；成员方法用于描述对象的行为，可简称为方法。
class 类名{
成员变量；
成员方法；
}
根据上述格式定义一个学生类，成员变量包括姓名（name）、年龄（age）、性别（sex）；成员方法包括读书read()。学生类定义的示例代码如下所示。
class Student {
String name; // 声明String类型的变量name
int age; // 声明int类型的变量age
String sex; // 声明String类型的变量sex
// 定义 read () 方法
void read() {
System.out.println("大家好，我是" + name + ",我在看书!");
}
}
以上代码中定义了一个学生类。其中，Student是类名，name、age、sex是成员变量，read()是成员方法，在成员方法read()中可以直接访问成员变量name。
在Java中，定义在类中的变量被称为成员变量，定义在方法中的变量被称为局部变量。
2.2 对象的创建与使用
上面定义了一个Student类，要想使用一个类则必须要创建该类的对象。在Java程序中可以使用new关键字创建对象，使用new关键字创建对象的具体格式如下：
类名 对象名称 = null;
对象名称 = new 类名();
上述格式中，创建对象分为声明对象和实例化对象两步，也可以直接通过下面的方式创建对象，具体格式如下：
类名 对象名称 = new 类名();
例如:Student stu = new Student();
创建对象后，可以使用对象访问类中的某个属性或方法，对象属性和方法的访问通过“.”运算符实现，具体格式如下。
对象名称.属性名
对象名称.方法名
class Student {
String name; // 声明姓名属性
void read() {
System.out.println("大家好，我是" + name + ",我在看书!");
}
}
public class Example03 {
public static void main(String[] args) {
Student stu = new Student();
stu.name = "李华";
stu.read();
}
}
2.3 对象的引用传递
类属于引用数据类型，引用数据类型就是指内存空间可以同时被多个栈内存引用。
class Student {
String name;
int age;
void read() {
System.out.println("大家好，我是" + name + "，年龄" + age);
}
}
public class Example03 {
public static void main(String[] args) {
Student stu1 = new Student();
Student stu2 = null;
stu2=stu1;
stu1.name = "小明";
stu1.age = 20;
stu2.age = 50;
stu1.read();
stu2.read();
}
}
stu1对象和stu2对象输出的内容是一致的，这是因为stu2对象获得了stu1对象的堆内存空间的使用权。第14行代码对stu1对象的age属性赋值之后，第15行代码通过stu2对象对age属性值进行了修改。实际上所谓的引用传递，就是将一个堆内存空间的使用权给多个栈内存空间使用，每个栈内存空间都可以修改堆内存空间的内容。
第一步声明对象stu1和stu2，并使用new创建Student对象赋值给stu1，使用new创建对象时会开辟一个堆内存空间，对象stu1指向开辟的堆内存地址0x001；
第二步通过对象stu1给对象stu2分配内存空间使用权，对象stu2指向堆内存地址0x001；第三步由于对象stu1指向堆内存地址0x001，所以对象stu1修改属性值时，就是修改堆内存中对象的值，堆内存中name的值修改为“小明”，age的值修改为20；
第四步与第三步类似，对象stu2也指向堆内存地址0x001，堆内存中age的值修改为50，最终结果对象stu1的age属性值也是50。
2.4 访问控制权限
在Java中，针对类、成员方法和属性，Java提供了4种访问控制权限，分别是private、default、protected和public。下面通过一张图将这4种访问控制权限按级别由小到大依次列出。
（1）private：private属于私有访问权限，用于修饰类的属性和方法，也可以修饰内部类。类的成员一旦使用了private关键字修饰，则该成员只能在本类中进行访问。
（2）default：default属于默认访问权限，如果一个类中的属性或方法没有任何的访问权限声明，则该属性或方法就是默认的访问权限，默认的访问权限可以被本包中的其他类访问，但是不能被其他包的类访问。
（3）protected：protected属于受保护的访问权限。如果一个类中的成员使用了protected访问权限，则只能被本包及不同包的子类访问。
（4）public：public属于公共访问权限。如果一个类中的成员使用了public访问权限，则该成员可以在所有类中被访问，不管是否在同一包中。
| 访问范围 | private | default | protected | public |
|---|---|---|---|---|
| 同一类中 | √ | √ | √ | √ |
| 同一包中的类 | √ | √ | √ | |
| 不同包的子类 | √ | √ | ||
| 全局范围 | √ |
如果一个Java源文件中定义的所有类都没有使用public修饰，那么这个Java源文件的文件名可以是一切合法的文件名；如果一个源文件中定义了一个public修饰的类，那么这个源文件的文件名必须与public修饰的类名相同。
3 封装性
3.1 为什么要封装
在Java面向对象的思想中，封装是指一种将类的实现细节包装、隐藏起来的方法。封装可以被认为是一个保护屏障，防止本类的代码和数据被外部类定义的代码随机访问。
class Student{
String name;
int age;
void read(){
System.out.println("大家好，我是"+name+"，年龄"+age);
}
}
public class Example03 {
public static void main(String[] args){
Student stu= new Student();
stu.name="张三";
stu.age=-19;
stu.read();
}
}
代码将age（年龄）属性赋值为-18岁，这在程序中是不会有任何问题的，因为int的值可以取负数。但在现实中，-18明显是一个不合理的年龄值。为了避免这种错误的发生，在设计Student类时，应该对成员变量的访问作出一些限定，不允许外界随意访问，这就需要实现类的封装。
3.2 如何实现封装
类的封装是指将对象的状态信息隐藏在对象内部，不允许外部程序直接访问对象的内部信息，而是通过该类提供的方法实现对内部信息的操作访问。封装的具体实现过程是，在定义一个类时，将类中的属性私有化，即使用private关键字修饰类的属性，私有属性只能在它所在的类中被访问。如果外界想要访问私有属性，需要提供一些使用public修饰的公有方法，其中包括用于获取属性值的getXxx()方法（也称为getter方法）和设置属性值的setXxx()方法（也称为setter方法）。
class Student{
private String name; // 声明姓名属性
private int age; // 声明年龄属性
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public int getAge() {
return age;
}
public void setAge(int age) {
if(age < 0){
System.out.println("您输入的年龄有误！");
} else {
this.age = age;
}
}
public void read() {
System.out.println("大家好，我是"+name+"，年龄"+age);
}
}
public class Example03 {
public static void main(String[] args) {
Student stu = new Student(); // 创建学生对象
stu.setName("张三"); // 为对象的name属性赋值
stu.setAge(-18); // 为对象的age属性赋值
stu.read(); // 调用对象的方法
}
}
4 构造方法
4.1 定义构造方法
构造方法是一个特殊的成员方法，在定义时，有以下几点需要注意。
（1）构造方法的名称必须与类名一致。
（2）构造方法名称前不能有任何返回值类型的声明。
（3）不能在构造方法中使用return返回一个值，但可以单独写return语句作为方法的结束。
class Student{
public Student() {
System.out.println("调用了无参构造方法");
}
}
public class Example03 {
public static void main(String[] args) {
System.out.println("声明对象...");
Student stu = null; //声明对象
System.out.println("实例化对象...");
stu = new Student(); //实例化对象
}
}
由上图所示的运行结果分析可知，当调用关键字new实例化对象时，程序调用了Student类的无参构造方法。
一个类中除了定义无参的构造方法外，还可以定义有参的构造方法，通过有参的构造方法可以实现对属性的赋值。通过下面一个案例演示有参构造方法的定义与调用。
class Student {
private String name;
private int age;
public Student(String n, int a) {
name = n;
age = a;
System.out.println("调用了有参构造方法");
}
public void read() {
System.out.println("我是:" + name + ",年龄:" + age);
}
}
public class Example03 {
public static void main(String[] args) {
Student stu = new Student("张三", 16);
stu.read();
}
}
4.2 构造方法的重载
与普通方法一样，构造方法也可以重载，在一个类中可以定义多个构造方法，但是需要每个构造方法的参数类型或参数个数不同。在创建对象时，可以通过调用不同的构造方法为不同的属性赋值。
class Student {
private String name;
private int age;
public Student() {
}
public Student(String n) {
name = n;
System.out.println("调用了一个参数的构造方法");
}
public Student(String n, int a) {
name = n;
age = a;
System.out.println("调用了两个参数的构造方法");
}
public void read() {
System.out.println("我是:" + name + ",年龄:" + age);
}
}
public class Example03 {
public static void main(String[] args){
Student stu1=new Student("李华");
Student stu2=new Student("张三",16);
stu1.read();
stu2.read();
}
}
5 this关键字
5.1 使用this关键字调用本类中的属性
在实际开发中，如果成员变量和局部变量的名称设置成一样的，会导致成员变量和局部变量的名称冲突。
class Student {
private String name;
private int age;
// 定义构造方法
public Student(String name,int age) {
name = name;
age = age;
}
public String read(){
return "我是:"+name+",年龄:"+age;
}
}
public class Example03 {
public static void main(String[] args) {
Student stu = new Student("张三", 18);
System.out.println(stu.read());
}
}
为了解决这个问题，Java提供了关键字this指代当前对象，通过this可以访问当前对象的成员。修改上述代码，使用this关键字指定当前对象属性，具体代码如下所示。
class Student {
private String name;
private int age;
// 定义构造方法
public Student(String name,int age) {
this.name = name;
this.age = age;
}
public String read(){
return "我是:"+name+",年龄:"+age;
}
}
public class Example03 {
public static void main(String[] args) {
Student stu = new Student("张三", 18);
System.out.println(stu.read());
}
}
5.2 使用this关键字调用成员方法
class Student {
public void openMouth() {
...
}
public void read() {
this.openMouth();
}
}
上述代码中，在read()方法中使用this关键字调用了openMouth()方法。需要注意的是此处的this关键字也可以省略不写。
5.3 使用this关键字调用构造方法
class Student {
private String name;
private int age;
public Student () {
System.out.println("调用了无参的构造方法");
}
public Student (String name,int age) {
this(); // 调用无参的构造方法
this.name = name;
this.age = age;
}
public String read(){
return "我是:"+name+",年龄:"+age;
}
}
public class Example03 {
public static void main(String[] args) {
Student stu = new Student("张三",18); // 实例化 Student对象
System.out.println(stu.read());
}
}
使用this调用类的构造方法时，应注意以下三点。
（1）只能在构造方法中使用this调用其他的构造方法，不能在成员方法中通过this调用构造方法。
（2）在构造方法中，使用this调用其他构造方法的语句必须位于第一行，且只能出现一次。
（3）不能在一个类的两个构造方法中使用this互相调用。
6 代码块
代码块，简单来讲，就是用{}括号括起来的一段代码，根据位置及声明关键字的不同，代码块可以分为4种：普通代码块、构造块、静态代码块、同步代码块。本节将针对普通代码块和构造块进行讲解。
普通代码块就是直接在方法或是语句中定义的代码块
构造代码块是直接在类中定义的代码块。
7 static关键字
7.1 静态属性
如果在Java程序中使用static修饰属性，则该属性称为静态属性（也称全局属性），静态属性可以使用类名直接访问，访问格式如下。
类名.属性名
class Student {
String name; // 定义name属性
int age; // 定义age属性
String school = "A大学"; // 定义school属性
public Student(String name, int age) {
this.name = name;
this.age = age;
}
public void info() {
System.out.println("姓名:" + this.name + "，年龄:" + this.age +
"，学校:" + school);
}
}
public class Example03 {
public static void main(String[] args) {
Student stu1 = new Student("张三", 18); // 创建学生对象
Student stu2 = new Student("李四", 19);
Student stu3 = new Student("王五", 20);
stu1.info();
stu2.info();
stu3.info();
//修改stu1对象的school的值
stu1.school = "B大学";
System.out.println("修改stu1学生对象的学生信息为B大学后");
stu1.info();
stu2.info();
stu3.info();
}
}
由上图可知，张三的学校信息由A大学修改为了B大学，而李四和王五的大学信息没有变化，表明非静态属性是对象所有，改变当前对象的属性值，不影响其他对象的属性值。
假设A大学改名成了B大学，而此时Student类已经产生了10万个学生对象，那么意味着，如果要修改这些学生对象的学校信息，则要把这10万个对象中的学校属性全部修改，共修改10万遍，这样肯定是非常麻烦的。
为了解决上述问题，可以使用static关键字修饰school属性，将其变为公共属性。这样，school属性只会分配一块内存空间，被Student类的所有对象共享，只要某个对象进行了一次修改，全部学生对象的school属性值都会发生变化。
class Student {
String name; // 定义name属性
int age; // 定义age属性
static String school = "A大学"; // 定义school属性
public Student(String name,int age){
this.name = name;
this.age = age;
}
public void info(){
System.out.println("姓名:" + this.name+"，年龄:" +this. age+
"，学校:" + school);
}
}
public class Example03 {
public static void main(String[] args) {
Student stu1 = new Student("张三",18); // 创建学生对象
Student stu2 = new Student("李四",19);
Student stu3 = new Student("王五",20);
stu1.info();
stu2.info();
stu3.info();
stu1.school = "B大学";//修改stu1对象的school的值
System.out.println("修改stu1学生对象的学生信息为B大学后");
stu1.info();
stu2.info();
stu3.info();
}
}
static关键字只能修饰成员变量，不能修饰局部变量，否则编译器会报错。
7.2 静态方法
如果想要使用类中的成员方法，就需要先将这个类实例化。而在实际开发时，开发人员有时希望在不创建对象的情况下，通过类名就可以直接调用某个方法，这时就需要使用静态方法，要实现静态方法只需要在成员方法前加上static关键字。
同静态变量一样，静态方法也可以通过类名和对象访问，具体如下所示。
类名.方法
或者
实例对象名.方法
class Student {
private static String school = "A大学"; // 定义school属性
private String name; // 声明name属性
private int age; // 声明age属性
public Student(String name, int age) {
this.name = name;
this.age = age;
}
public static String getSchool() {
return school;
}
public static void setSchool(String s) {
school = s;
}
public void info() {
System.out.println("姓名:" + this.name + "，年龄:" + this.age +
"，学校:" + school);
}
}
class Example03 {
public static void main(String[] args) {
Student stu1 = new Student("张三", 18); // 创建学生对象stu1
Student stu2 = new Student("李四", 19); // 创建学生对象stu2
Student stu3 = new Student("王五", 20); // 创建学生对象stu3
System.out.println("----修改前----");
stu1.info();
stu2.info();
stu3.info();
System.out.println("----修改后----");
Student.setSchool("B大学"); //为静态属性school重新赋值
stu1.info();
stu2.info();
stu3.info();
}
}
静态方法只能访问静态成员，因为非静态成员需要先创建对象才能访问，即随着对象的创建，非静态成员才会分配内存。而静态方法在被调用时可以不创建任何对象。
7.3 静态代码块
在Java类中，用static关键字修饰的代码块称为静态代码块。当类被加载时，静态代码块就会执行，由于类只加载一次，所以静态代码块只执行一次。在程序中，通常使用静态代码块对类的成员变量进行初始化。
class Student{
String name; //成员属性
{
System.out.println("我是构造代码块");
}
static {
System.out.println("我是静态代码块");
}
public Student(){ //构造方法
System.out.println("我是Student类的构造方法");
}
}
class Example03{
public static void main(String[] args) {
Student stu1 = new Student();
Student stu2 = new Student();
Student stu3 = new Student();
}
}
首先介绍了面向对象的思想；
其次介绍了类与对象之间的关系，包括类的定义、对象的创建与使用、对象的引用传递和访问控制；
接着介绍了类的封装，包括为什么要封装以及如何实现封装；
接着介绍了构造方法，包括构造方法的定义与重载；
然后介绍了this关键字的使用，包括使用this关键字调用本类中的属性、成员变量和构造方法；
最后介绍了代码块的使用以及static关键字的使用。
（1）包名中所有字母小写
（2）类名和接口名的每个首字母都大写，ArrayList
（3）常量名中所有字母都大写，单词之间用下画线连接，DAY_OF_MONTH
（4）变量名和方法名的第一个单词首字母小写，从第二个单词开始每个单词首字母大写，lineNumber，getLineNumber
（5）在程序中，尽量使用有意义的英文单词定义标识符，使程序便于阅读，userName定义用户，password定义密码