JavaSE 第二章面向对象之构造、封装、继承

2.7 构造方法

构造方法作用

创建一个类的对象，并给对象的数据进行初始化

构造方法格式

方法名与类名相同；

没有返回值类型，连void都没有，没有具体的返回值。

public class Student {	
	public Student() {
		System.out.println("这是构造方法");
	}
}

public class StudentDemo {
	public static void main(String[] args) {
		//如何调用构造方法呢?
		//通过new关键字调用
		//格式：类名 对象名 = new 构造方法(...);
		Student s = new Student();
	}
}

注意：

如果你不提供构造方法，系统会给出默认构造方法；

如果你提供了构造方法，系统将不再提供；

构造方法也是可以重载的,重载条件和普通方法相同。

public class Student {
	private String name;
	private int age;
	
	public Student() {}
	
	public Student(String name) {
		this.name = name;
	}
	
	public Student(int age) {
		this.age = age;
	}
	
	public Student(String name,int age) {
		this.name = name;
		this.age = age;
	}
	
	public void show() {
		System.out.println(name+"---"+age);
	}
}


public class StudentTest {
	public static void main(String[] args) {
		//如何调用构造方法呢?
		//其实通过new关键字就可以
		//格式：类名 对象名 = new 构造方法名(...);
		Student s = new Student();
		s.show();
		
		//public Student(String name)
		Student s2 = new Student("孙俪");
		s2.show();
		
		//public Student(int age)
		Student s3 = new Student(30);
		s3.show();
		
		//public Student(String name,int age)
		Student s4 = new Student("孙俪",30);
		s4.show();
	}
}

2.8 封装

封装是面向对象三大特征之一，是面向对象编程语言对客观世界的模拟，客观世界里成员变量都是隐藏在对象内部的，外界无法直接操作和修改。

封装原则，将不需要对外提供的内容都隐藏起来，把属性隐藏，提供公共方法对其访问，成员变量private，提供对应的getXxx()/setXxx()方法。

封装的好处，通过方法来控制成员变量的操作，提高了代码的安全性，把代码用方法进行封装，提高了代码的复用性。

2.9 继承

2.9.1 概述

如果有多个类中有相同的特征和行为（属性和方法），并且这多个类之间从逻辑上讲是有一定的关联的。那么此时，我们可以将这些共同的部分单独写到一个类中。

• Monkey: name, age, gender, walk(), sleep(), eat()

• Tiger: name, age, gender, walk(), sleep(), eat()

• Elephent: name, age, gender, walk(), sleep(), eat()

可以将上述三种类中，共同的部分提取出来

Animal： name, age, gender, walk(), sleep(), eat()

此时，被提取出的这个类，称作是–父类，基类，超类

具有相同特征的那些类，称作是–子类，派生类

从A类派生出B类：A是B的父类，B是A的子类

他们之间的关系，是继承：子类继承自父类

为什么使用继承：

代码复用+功能拓展

继承的实现

通过extends关键字可以实现类与类的继承

格式：

public class 子类名 extends 父类名{}

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

	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 class Student extends Person {
	public void study() {
		System.out.println("学生要学到");
	}
}


public class Teacher extends Person {
	public void teach() {
		System.out.println("老师要讲到");
	}
}

2.9.2 继承的优缺点

优点：

• 提高了代码的复用性： 多个类相同的成员可以放到同一个类中;

• 提高了代码的维护性：如果功能的代码需要修改，修改一处即可;

• 让类与类之间产生了关系，是多态的前提;

缺点

• 好处的第三点同时也是继承的弊端,类与类之间产生了关系，让类的耦合性增强了;
• 设计原则：高内聚低耦合;

Java继承中成员变量的特点

• 成员变量名称不一样，使用的时候非常简单

• 成员变量名称一样的情况：

  • 在子类中访问变量：（就近原则）
  • 在方法的局部范围找，如果有就使用
  • 在子类的成员范围找，如果有就使用
  • 在父类的成员范围找，如果有就使用
  • 如果还找不到 就报错

public class Father {
	//为了演示案，这里使用public修饰了成员变量，实际开发中用private
	//年龄
	public int age = 45;
}


public class Son extends Father {
	//身高
	public int height = 170;
	//年龄
	public int age = 20;
	
	public void show() {
		System.out.println(height);
		System.out.println(age);
	}
	
	public void printAge() {
		int age = 10;
		System.out.println(age);
	}
}


public class ExtendsTest {
	public static void main(String[] args) {
		Son s = new Son();
		//s.show();
		s.printAge();
	}
}

2.9.3 super关键字

• super含义

  • this代表本类对象的引用
  • super代表父类存储空间的标识（可以理解为父类对象引用）

• 用法（this和super均可如下使用）

  • 访问成员变量

    this.成员变量 super.成员变量

  • 访问构造方法

    this(…) super(…)

  • 访问成员方法

    this.成员方法() super.成员方法()

public class Father {
	public int age = 45;
}

public class Son extends Father {
	public int age = 20;
	public void printAge() {
	int age = 10;
	System.out.println(age);
	//我要访问子类成员范围的age
  System.out.println(this.age);
  //我要访问父类成员范围的age
  System.out.println(super.age);
}

}

public class ExtendsTest {
public static void main(String[] args) {
Son s = new Son();
s.printAge();
}
}

2.9.4 继承中的构造方法

一个对象在实例化的时候，需要先去实例化从父类继承到的成员，因为子类继承父类，会继承父类的非私有成员。

而子类在初始化的时候，可能会使用父类的数据，如果父类数据没有先初始化，子类就不能使用这些数据，所以，在子类初始化之前，一定要先完成父类数据的初始化。

在实例化父类部分的时候，默认使用父类中的无参构造

问题：如果父类中没有无参构造，或者父类中的无参构造子类无法访问（使用private修饰无参构造），则此时子类对象无法完成实例化。

解决：

1. 给父类中添加一个子类能够访问到的无参构造方法

2. 在子类的构造方法中，手动调用父类中能够访问到的构造方法，来实例化父类部分

public class Father {
	
	public Father() {
		System.out.println("Father无参构造方法");
	}
	
	
	public Father(String name) {
		System.out.println("Father带参构造方法");
		System.out.println(name);
	}
}

public class Son extends Father {
	public Son() {
		//super();
		super("杨幂");
		System.out.println("Son无参构造方法");
	}
	
	public Son(String name) {
		//super();
		super("杨幂");
		System.out.println("Son带参构造方法");
		System.out.println(name);
	}
}

public class ExtendsTest {
	public static void main(String[] args) {
		Son s = new Son();
		System.out.println("---------");
		Son s2 = new Son("小幂");
	}
}

2.9.5 继承中成员方法

通过子类对象去访问一个方法

• 首先在子类中找

• 然后在父类中找

• 如果还是没有就会报错

public class Father {
	public void show() {
		System.out.println("Father show");
	}
}
/*
 * Java继承中成员方法的访问特点：
 * 		A:子类中方法和父类中方法的声明不一样，这个太简单
 * 		B:子类中方法和父类中方法的声明一样，调用的到底是谁的呢?
 * 			执行的是子类中的方法。
 */
public class Son extends Father {
	public void method() {
		System.out.println("Son method");
	}
	
	public void show() {
		System.out.println("Son show");
	}
}

public class ExtendsTest {
	public static void main(String[] args) {
		Son s = new Son();
		s.method();
		s.show();
		//s.function();
	}
}

2.9.6 方法重写

用子类的方法实现覆盖掉父类的实现

方法重写：子类中出现了和父类中一摸一样的方法声明

应用：当子类需要父类的功能，而功能主体子类有自己特有的内容时，可以重写父类中的方法，这样，即沿袭了父类的功能，又定义了子类特有的内容

注意:

注解

@Override:

是一个注解，常用在方法的重写中。表示在进行方法重写之前，进行一个验证。验证这个方法，到底是不是在重写父类中的方法。这个注解，可以添加，也可以不添加。但是，一般情况下，我们都是要加上去的

• 表明该方法的重写父类的方法

• 方法重写的注意事项

• 父类中私有方法不能被重写

• 子类重写父类方法时，访问权限不能更低

• 子类重写父类方法时，建议访问权限一摸一样

注意：

• 访问权限问题：

  子类方法的访问权限不能比父类方法中的访问权限低，要大于等于父类方法的访问权限

  public > protected > default > private

• 关于返回值类型：在重写的时候，要求方法名和参数必须和父类中方法相同

  子类方法的返回值类型可以和父类方法中返回值类型相同。也可以是父类方法中返回值类型的子类型。

  重载和重写

public class Phone {
	public void call(String name) {
		System.out.println("给"+name+"打电话");
	}
}

public class NewPhone extends Phone {
	
	public void call(String name) {
		System.out.println("开启视频功能");
		super.call(name);
	}
}
/*
 * 方法重写：子类中出现了和父类中一模一样的方法声明的情况。
 * 
 * 方法重写的应用：
 * 		当子类需要父类的功能，而功能主体子类又有自己的特有内容的时候，就考虑使用方法重写，
 * 		这样即保证了父类的功能，还添加了子类的特有内容。
 */
public class PhoneTest {
	public static void main(String[] args) {
		Phone p = new Phone();
		p.call("孙俪");
		System.out.println("-----------");
		NewPhone np = new NewPhone();
		np.call("孙俪");
	}
}

继承的特点

• Java语言是单继承的，一个类只能有一个父类，一个类可以有多个子类

  在某些语言中是支持多继承的。例如：C++、python…

  但是在多继承中，会有一个问题：二义性。

  虽然很多语言都抛弃了多继承，但是还是会用其他的方式来间接的实现类似多继承。

  例如：在java中是用接口实现的。

• Java中所有的类都直接或者简介的继承自 Object 类

• 子类可以访问到父类中能看的见的成员：被public或者protected修饰的

• 构造方法不能继承。