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

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初始化块

执行顺序

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

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

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

示例及运行结果：