【Java】Java进阶学习笔记（一）—— 面向对象（封装）

一、类中成分

1、类中成分

1. 成员变量(Field:描述类和对象的属性信息的)

2. 成员方法(Methpd:描述类或者对象的行为信息的)：包括实例方法，静态方法，抽象方法，getter setter 方法

3. 构造器(Constructor:初始化一个类的对象并返回引用)
   * 默认无参构造器：一个类默认会自带一个无参构造器，即使不写构造器，也有构造器存在，但是如果一个类它写了一个构造器，那么默认的无参构造器就被覆盖了！
   * 有参构造器

4. 代码块

5. 内部类

/*javaBean类: 封装数据
*/
public class Student {// 两个成员变量 私有private String name;private int age;// 无参构造器public Student(){}// 有参数构造器public Student(String name,int age){this.name = name;this.age = age;}// 成员方法: setXX \ gerXXpublic void setName(String name){this.name = name;        }public String getName(){return name;}public void setAge(int age){this.age = age}public int getAge(){return age;}public void show(){System.out.print;n(name + "..." + age);}}

2、this关键字

• this关键字可以用在实例方法和构造器中

（1）this 关键字用在方法中，谁调用这个方法，this 就代表谁；
（2）this 关键字用在构造器上，代表了构造器正在初始化那个对象的引用。

注意：对于static修饰的方法而言，可以直接使用类来调用该方法，如果在ststic修饰的方法中使用this关键字，则这个关键字就会无法指向合适的对象，所以，static修饰的方法中不能用this引用，并且Java语法规定，静态成员不能直接访问非静态成员；

/*javaBean类: 封装数据
*/
public class Student {// 两个成员变量 私有private String name;private int age;// 无参构造器public Student(){}// 有参数构造器中可以用 this 关键字public Student(String name,int age){this.name = name;this.age = age;}// 实例方法中可以用 this 关键字// 成员方法: setXX \ gerXXpublic void setName(String name){this.name = name;        }public String getName(){return name;}public void setAge(int age){this.age = age}public int getAge(){return age;}public void show(){System.out.print;n(name + "..." + age);}   
}

this() 访问构造器方法

作用：this() 用于访问本类的构造方法（构造器是类的一种特殊方法，方法名称和类名相同，没有返回值，括号中可以有参数，如果有参数就是有参构造方法）

• 通过一个构造器方法1去调用另一个构造器方法2，实现代码复用；
• 构造器方法1和构造器方法2都在同一个类中；
• 语法：this(实参列表）；
• this(实参列表）的使用只能出现在第一个构造方法的第一行。

例：创建一个Student学生类，利用this(“实参列表”)给实例变量name赋值

通过this("实参列表")调用类中的有参构造器对name进行赋值
this("实参列表“）必须放在第一个构造器的第一行

public class Student {public String name;//无参构造器public Student() {//通过this(“实参列表"）调用类中的有参构造器对name进行赋值//this("有参构造")必须放在第一个构造器的第一行this("甲");}//有参构造器public Student(String name) {this.name = name;}}

在测试类中。利用new关键字new一个对象出来后，打印输出name的值为甲。

代码示例如下：

public class DemoApplication {public static void main(String[] args) {//利用new关键字new一个Student类的对象Student student = new Student();//控制台打印输出结果为：甲System.out.println(student.name);}
}

3、static关键字

– 按照有无static修饰，成员变量和方法可以分为

1. 成员变量的区分

（1）静态成员变量(类变量)

有 static 修饰的成员变量称为静态成员变量，也叫类变量，属于类本身，直接用类名访问即可。

（2）实例成员变量

无 static 修饰的成员变量称为实例成员变量，属于类的每个对象的，必须用类的对象来访问。

2. 成员方法的区分

（1）静态方法

有static修饰的成员方法称为静态方法，也叫类方法，属于类本身的，直接用类名访问即可。

（2）实例方法

无static修饰的成员方法称为实例方法，属于类的每个对象的，必须用类的对象来访问。

3. 成员变量访问语法的区分

（1）静态成员变量访问：
类名.静态成员变量
对象.静态成员变量（也可以访问，但是不推荐）
（2）实例成员变量的访问：
对象.实例成员变量

public class Student {// 1.静态成员变量: 有static修饰，属于类本身，直接用类名访问即可！public static String schoolName = "中国";// 2.实例成员变量: 无static修饰，属于类的对象，必须用对象访问private String name;private int age;public static void main(String[] args){// 1.类名.静态成员变量System.out.println(Student.schoolName);// 注意:同一个类中访问静态成员变量可以省略类名不写System.out.println(schoolName);// 2.对象.实例成员变量Student s1 = new Student();s1.name = "孙悟空";System.out.println(s1.name);// 3.对象.静态成员变量(不推荐)System.out.println(s1.schoolName);// 静态成员变量属于类，直接用类名访问即可}
}

二、封装

1、封装的定义

封装就是隐藏对象的属性和实现细节，仅提供公共访问方式来让外界访问。当内部的逻辑发生变化时，外部调用不用因此而修改，它们只调用开放的接口，而不用去关心内部的实现。

封装的好处

1. 良好的封装能够减少耦合。2. 类内部的结构可以自由修改。3. 可以对成员变量进行更精确的控制。4. 隐藏信息，实现细节。

2、实现Java封装的步骤

1. 修改属性的可见性来限制对属性的访问（一般限制为private），例如：

public class Person {private String name;private int age;
}

2. 对每个值属性提供对外的公共方法访问，也就是创建一对赋取值方法，用于对私有属性的访问，例如：

public class Person{private String name;private int age;
​public int getAge(){return age;}
​public String getName(){return name;}
​public void setAge(int age){this.age = age;}
​public void setName(String name){this.name = name;}
}

采用 this 关键字是为了解决实例变量（private String name）和局部变量（setName(String name)中的name变量）之间发生的同名的冲突。

3、封装实例

/* 文件名: EncapTest.java */
public class EncapTest{private String name;private String idNum;private int age;public int getAge(){return age;}public String getName(){return name;}public String getIdNum(){return idNum;}public void setAge( int newAge){age = newAge;}public void setName(String newName){name = newName;}public void setIdNum( String newId){idNum = newId;}
}

以上实例中public方法是外部类访问该类成员变量的入口。通常情况下，这些方法被称为getter和setter方法。
因此，任何要访问类中私有成员变量的类都要通过这些getter和setter方法。

/* F文件名 : RunEncap.java */
public class RunEncap{public static void main(String args[]){EncapTest encap = new EncapTest();encap.setName("James");encap.setAge(20);encap.setIdNum("12343ms");System.out.print("Name : " + encap.getName()+ " Age : "+ encap.getAge());}
}

以上代码编译运行结果如下:

Name : James Age : 20

4、IDEA 行为封装的快捷键

1. 点击右键，选择Generate

2. 选择Getter and Setter

3. 选择要进行封装的属性（按住Shift可多选），点击ok

5、在类的封装中加入抛出异常判断

定义一个 Car类，封装其属性 name 和 color，
对于 color属性来说，不能为 red，否则爆红。
对于 name属性来说，不能传入 null，否则报错。

public class Car {private String name;private String color;public String getName() {return name;}public void setName(String name) {/*** 判断 如果在启动项中赋值name为空 抛出异常*/if ( name == null) {throw new IllegalArgumentException("invalid name");}this.name = name;}public String getColor() {return color;}public void setColor(String color) {/*** 判断 如果在启动项中赋值color为red 抛出异常*/if ( name == null || name.isEmpty() ) {throw new IllegalArgumentException("invalid name");}this.color = color;}
}

在测试文件中：

public class DemoApplication {public static void main(String[] args) {Car car = new Car();car.setColor("red");System.out.println("车子的颜色为--------------------"+car.getColor());car.setName(" ");System.out.println("车子的名字为---------------------"+car.getName());}
}

控制台报错如下：