【Java】Java进阶学习笔记（一）—— 面向对象（封装）
- 一、类中成分
- 1、类中成分
- 2、this关键字
- this() 访问构造器方法
- 3、static关键字
- 1. 成员变量的区分
- 2. 成员方法的区分
- 3. 成员变量访问语法的区分
- 二、封装
- 1、封装的定义
- 封装的好处
- 2、实现Java封装的步骤
- 3、封装实例
- 4、IDEA 行为封装的快捷键
- 5、在类的封装中加入抛出异常判断
一、类中成分
1、类中成分
-
成员变量(Field:描述类和对象的属性信息的)
-
成员方法(Methpd:描述类或者对象的行为信息的)：包括实例方法，静态方法，抽象方法，getter setter 方法
-
构造器(Constructor:初始化一个类的对象并返回引用)
* 默认无参构造器：一个类默认会自带一个无参构造器，即使不写构造器，也有构造器存在，但是如果一个类它写了一个构造器，那么默认的无参构造器就被覆盖了！
* 有参构造器 -
代码块
-
内部类
/*
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 \ gerXX
public 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 \ gerXX
public 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封装的步骤
- 修改属性的可见性来限制对属性的访问（一般限制为private），例如：
public class Person {
private String name;
private int age;
}
- 对每个值属性提供对外的公共方法访问，也就是创建一对赋取值方法，用于对私有属性的访问，例如：
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 行为封装的快捷键
- 点击右键，选择Generate
- 选择Getter and Setter
- 选择要进行封装的属性（按住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());
}
}
控制台报错如下：
