面向对象（一）（封装，继承，多态，继承与组合，初始化块）

1. 封装

封装（Encapsulation）是指把对象的状态信息隐藏在对象的内部，不允许程序直接访问对象的内部信息，要通过他提供的方法来对内部的信息进行访问和操作。

访问控制符解释：

private：当前类访问权限

default：包访问权限

protect：子类访问权限

public：公共访问权限

示例：

class Person{
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) {
this.age = age;
}
public Person(String name, int age) {
super();
this.name = name;
this.age = age;
}
public String toString() {
return "Person [name=" + name + ", age=" + age + "]";
}

}

2. 继承

继承通过关键字extends来实现的，实现继承的类被称为子类，被继承的类称为父类，有的也称为基类，或者超类。

示例：

public class Demo01 {
public static void main(String[] args) {
Student s1 = new Student("张一", 19, 89.3);
Student s2 = new Student("李二", 18, 80);
Student s3 = new Student("王三", 17, 99.3);
System.out.println(s1);
System.out.println(s2);
System.out.println(s3);

}

}

class Student extends Person{
private double grade;//学生除了人的共性属性外，还有特有属性，成绩

public Student(String name, int age, double grade) {
super(name, age);
this.grade = grade;

}

public double getGrade() {
return grade;
}

public void setGrade(double grade) {
this.grade = grade;
}

public String toString() {//子类重写toString()方法

return super.toString()+"Student [grade=" + grade + "]";
}

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

public Person(){   //注意：一般把父类的无参构造函数写上，子类不用显示继承父类构造函数

}
public Person(String name, int age) {
super();
this.name = name;
this.age = age;
}

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

public String toString() {
return "Person [name=" + name + ", age=" + age + "]";
}

}

运行结果：



3.多态

Java引用变量有两个类型：一个是编译时类型，一个是运行时类型。编译时由声明该变量时使用的类型决定，运行时由实赋给该变量的对象决定。如果编译时和运行时的类型不一致，就是所谓的多态。

注意：利用关键字instanceof 可以判断类型，进行强转，避免发生类型转换错误。

示例：

public class Demo01 {
public static void main(String[] args) {
Person s1 = new Student("张一", 19, 89.3);
Person t2 = new Teacher("郭天", 18, "一级教师");

System.out.println(s1);
System.out.println(t2);

if(t2 instanceof Teacher){//对象类型判断
Teacher teacher = (Teacher)t2;//强转为老师
teacher.job();//调用老师特有的方法
}

}

}

class Teacher extends Person {
private String classJob;// 职称

public Teacher(String name, int age, String classJob) {
super(name, age);
this.classJob = classJob;
}

public String getClassJob() {
return classJob;
}

public void setClassJob(String classJob) {
this.classJob = classJob;
}

public void job(){
System.out.println("每天的工作是上课。");
}

public String toString() {
return super.toString() + "Teacher [classJob=" + classJob + "]";
}

}

class Student extends Person {
private double grade;// 学生除了人的共性属性外，还有特有属性，成绩

public Student(String name, int age, double grade) {
super(name, age);
this.grade = grade;

}

public double getGrade() {
return grade;
}

public void setGrade(double grade) {
this.grade = grade;
}

public String toString() {// 子类重写toString()方法

return super.toString() + "Student [grade=" + grade + "]";
}

}

class Person {
private String name;
private int age;

public Person() { // 注意：一般把父类的无参构造函数写上，子类不用显示继承父类构造函数

}

public Person(String name, int age) {
super();
this.name = name;
this.age = age;
}

public String getName() {
return name;
}

public void setName(String name) {
this.name = name;
}

public int getAge() {
return age;
}

public void setAge(int age) {
this.age = age;
}

public String toString() {
return "Person [name=" + name + ", age=" + age + "]";
}

}

运行结果：



4.继承与组合

组合是把旧的对象作为新类的成员变量组合进来，用来实现新的功能，用户看到新类的方法，但是看不到组合对象的方法。

把学生作为老师的成员属性。

示例：

public class Demo01 {
public static void main(String[] args) {
Student student = null;
Person s1 = new Student("张一", 19, 89.3);
if(s1 instanceof Student){
student = (Student) s1;
}
Person t2 = new Teacher("郭天", 18, "一级教师",student);

System.out.println(s1);
System.out.println(t2);

if(t2 instanceof Teacher){//对象类型判断
Teacher teacher = (Teacher)t2;//强转为老师
teacher.job();//调用老师特有的方法
}

}

}

class Teacher extends Person {
private String classJob;// 职称
private Student student;//把学生对象作为老师的成员变量

public Teacher(String name, int age, String classJob, Student student) {
this(name, age,classJob);
this.student = student;
}

public Teacher(String name, int age, String classJob) {
super(name, age);
this.classJob = classJob;
}

public String getClassJob() {
return classJob;
}

public void setClassJob(String classJob) {
this.classJob = classJob;
}

public void job(){
System.out.println("有学生：" + student.toString());
System.out.println("每天的工作是上课。");
}

public String toString() {
return super.toString() + "Teacher [classJob=" + classJob + "]";
}

}

class Student extends Person {
private double grade;// 学生除了人的共性属性外，还有特有属性，成绩

public Student(String name, int age, double grade) {
super(name, age);
this.grade = grade;

}

public double getGrade() {
return grade;
}

public void setGrade(double grade) {
this.grade = grade;
}

public String toString() {// 子类重写toString()方法

return super.toString() + "Student [grade=" + grade + "]";
}

}

class Person {
private String name;
private int age;

public Person() { // 注意：一般把父类的无参构造函数写上，子类不用显示继承父类构造函数

}

public Person(String name, int age) {
super();
this.name = name;
this.age = age;
}

public String getName() {
return name;
}

public void setName(String name) {
this.name = name;
}

public int getAge() {
return age;
}

public void setAge(int age) {
this.age = age;
}

public String toString() {
return "Person [name=" + name + ", age=" + age + "]";
}

}

运行结果：



5初始化块

执行顺序

静态初始化块→普通初始化块→构造函数

静态初始化块是类相关，只执行一次

普通初始化块，构造函数都是对象相关，每次创建新的对象都会执行

示例及运行结果：