Java基础-Day03
1、面向对象三大特性介绍
封装(encapsulation)[n1]
将类的某些信息隐藏在类内部，不允许外部程序直接访问，而是通过该类提供的方法来实现对隐藏信息的操作和访问。
好处：
只能通过规定的方法访问数据。
隐藏类的实例细节，方便修改和实现。
封装步骤：
继承(inheritance)
继承是类与类的一种关系，是一种“is a”的关系。比如“狗”继承“动物”，这里动物类是狗类的父类或者基类，狗类是动物类的子类或者派生类。如下图所示：
java中的继承是单继承，即一个类只有一个父类。
子类拥有父类的所有属性和方法（除了private修饰的属性不能拥有）从而实现了实现代码的复用；
多态(polymorphism)
面向对象的最后一个特性就是多态，那么什么是多态呢？多态就是对象的多种形态。
2.继承
为何需要继承
继承概述
多个类中存在相同属性和行为时，将这些内容抽取到单独一个类中，那么多个类无需再定义这些属性和行为，只要继承那个类即可。
通过extends关键字可以实现类与类的继承
class 子类名 extends 父类名 {}
单独的这个类称为父类，基类或者超类；这多个类可以称为子类或者派生类。
有了继承以后，我们定义一个类的时候，可以在一个已经存在的类的基础上，还可以定义自己的新成员
继承实战
使用继承前:
观察打印结果:
使用继承后：
观察打印结果:
继承的好处
提高了代码的复用性
多个类相同的成员可以放到同一个类中
提高了代码的维护性
如果功能的代码需要修改，修改一处即可
让类与类之间产生了关系，是多态的前提
其实这也是继承的一个弊端：类的耦合性很强
Java继承的特点
Java只支持单继承，不支持多继承。
一个类只能有一个父类，不可以有多个父类。
class SubDemo extends Demo{} //ok
class SubDemo extends Demo1,Demo2...//error
Java支持多层继承(继承体系)
class A{}
class B extends A{}
class C extends B{}
多继承 实战演示:
多层继承实战演示:
Java继承的注意点
子类只能继承父类所有非私有的成员(成员方法和成员变量)
其实这也体现了继承的另一个弊端：打破了封装性
子类不能继承父类的构造方法，但是可以通过super(后面讲)关键字去访问父类构造方法。
不要为了部分功能而去继承
我们到底在什么时候使用继承呢?
继承中类之间体现的是：”is a”的关系
私有成员无法继承
package com.yueqian.day1;
class Father {
privateintnum = 10;
publicintnum2 = 20;
privatevoid show1() {
System.out.println("show1...");
}
publicvoid show2() {
System.out.println("show2....");
}
}
class Son extends Father {
}
publicclass Demo {
publicstaticvoid main(String[] args) {
Son s = new Son();
// s.show1(); // 私有方法无法继承
s.show2();
System.out.println(s.num2);
// System.out.println(s.num); 私有成员无法继承
}
}继承中成员变量的关系
继承中成员变量的关系:
A:子类中的成员变量和父类中的成员变量名称不一样，这个太简单。
package com.yueqian.day111;
class Father{
public intnum = 10;
}
class Son extends Father
{
publicintnum2 = 20;
publicvoid show()
{
System.out.println(num);
System.out.println(num2);
}
}
publicclass Demo {
publicstaticvoid main(String[] args) {
Son s = new Son();
s.show();
}
}观察打印；
B:子类中的成员变量和父类中的成员变量名称一样，这个怎么玩呢?
就近原则
在子类方法中访问一个变量的查找顺序：
a:在子类方法的局部范围找，有就使用
b:在子类的成员范围找，有就使用
c:在父类的成员范围找，有就使用
d:如果还找不到，就报错。
super关键字
super的基本使用
先回忆this关键字
package com.yueqian.day1212;
class Father
{
publicintnum = 10;
}
class Son extends Father
{
publicintnum = 20;
publicvoid show()
{
intnum = 100;
System.out.println(num);
}
}
publicclass Demo {
publicstaticvoid main(String[] args) {
Son s = new Son();
s.show();
}
}接下来，我除了想访问局部变量num，我还想访问成员变量num，怎么办呢?
class Father {
publicintnum = 10;
}
class Son extends Father {
publicintnum = 20;
publicvoid show() {
intnum = 100;
System.out.println(num);
// 使用this访问成员变量
System.out.println(this.num);
}
}
publicclass Demo {
publicstaticvoid main(String[] args) {
Son s = new Son();
s.show();
}
}接下来，我除了想访问局部变量，还想访问成员变量，还想访问父类的成员变量的值怎么办呢?
package com.yueqian.day1212;
class Father {
publicintnum = 10;
}
class Son extends Father {
publicintnum = 20;
publicvoid show() {
intnum = 100;
System.out.println(num);
// 使用this访问成员变量
System.out.println(this.num);
// 使用super关键字访问父类成员变量的值
System.out.println(super.num);
}
}
publicclass Demo {
publicstaticvoid main(String[] args) {
Son s = new Son();
s.show();
}
}super和this的区别
super的用法和this很像
this代表本类对象的引用。
super代表父类存储空间的标识(可以理解为父类引用)
用法(this和super均可如下使用)
访问成员变量
this.成员变量 super.成员变量
访问构造方法
this(…) 调用本类的构造方法
super(…) 调用父类的构造方法
访问成员方法
成员方法的重载
this.成员方法() 本类的成员方法
super.成员方法() 父类的成员方法
继承中构造方法的关系
子类中所有的构造方法默认都会访问父类中空参数的构造方法
为什么呢?
因为子类会继承父类中的数据，可能还会使用父类的数据。所以，子类初始化之前，一定要先完成父类数据的初始化。
每一个构造方法的第一条语句默认都是：super()
继承构造方法实战:
子类默认会去调用父类的无参构造！
实战2:
class Father {
public Father() {
System.out.println("Father 的无参构造方法..");
}
public Father(String name) {
System.out.println("Father的有参构造方法....");
}
}
class Son extends Father {
public Son() {
System.out.println("Son的无参数构造方法..");
}
public Son(String name)
{
System.out.println("Son的有参构造方法....");
}
}
publicclass Demo2 {
publicstaticvoid main(String[] args) {
//Son s = new Son();
//System.out.println("--------------");
Son s2 = new Son("王小丫");
}
}继承中构造方法的注意点
如果父类中没有构造方法，该怎么办呢?
子类通过super去显示调用父类其他的带参的构造方法
子类通过this去调用本类的其他构造方法
本类其他构造也必须首先访问了父类构造
一定要注意：
super(…)或者this(….)必须出现在第一条语句上
否则，就会有父类数据的多次初始化
父类没有无参，子类继承父类，直接报错
思考：如果父类中无参不写呢?会怎么样 [n2]
子类默认会访问父类无参构造，如果父类没有无参构造，会报错，如何解决呢?
- 父类中不写，编译器会赠送一个
- 手动添加一个无参构造给父类
- [n3] 父类的有参构造
this调用本类中其它构造
class Father {
public Father(String name) {
System.out.println("父类的有参构造...");
}
}
class Son extends Father {
public Son() {
super("哈哈");
System.out.println("Son的无参构造");
}
public Son(String name) {
this();
System.out.println("Son的有参构造....");
}
}
publicclass Demo {
publicstaticvoid main(String[] args) {
Son s = new Son();
}
}this或者super 必须放在构造方法中第一句话
继承中成员方法的关系
案例演示
子父类中同名和不同名的成员方法
结论：
通过子类对象去访问一个方法
首先在子类中找
然后在父类中找
如果还是没有就报错。(不考虑父亲的父亲…)
父类中成员方法和子类中不一样
class Father {
publicvoid show() {
System.out.println("父类的show....");
}
}
class Son extends Father {
publicvoid aa() {
System.out.println("子类的aa方法");
}
}
publicclass Demo {
publicstaticvoid main(String[] args) {
Son s = new Son();
s.aa();
s.show();
}
}
子类中成员方法和父类中成员方法一样[n4]
方法重写
子类中出现了和父类中一模一样的方法声明，也被称为方法覆盖，方法复写
使用特点：
如果方法名不同，就调用对应的方法
如果方法名相同，最终使用的是子类自己的
方法重写的应用：
当子类需要父类的功能，而功能主体子类有自己特有内容时，可以重写父类中的方法，这样，即沿袭了父类的功能，又定义了子类特有的内容。
代码实战:
class Phone
{
publicvoid Call(String name)
{
System.out.println("给"+name+"打电话");
}
}
class NewPhone
{
publicvoid Call(String name)
{
System.out.println("给"+name+"打电话");
System.out.println("可以听音乐");
}
}
publicclass Demo {
}改进版:
class Phone {
publicvoid Call(String name) {
System.out.println("给" + name + "打电话");
}
}
class NewPhone extends Phone {
publicvoid Call(String name) {
System.out.println("给" + name + "打电话");
System.out.println("可以听音乐");
}
}
publicclass Demo {
publicstaticvoid main(String[] args) {
NewPhone np = new NewPhone();
np.Call("王二丫");
}
}
升级版本:
方法重写的注意点
父类中私有方法不能被重写
子类重写父类方法时，访问权限不能更低
父类静态方法，子类也必须通过静态方法进行重写。[n5]
- [n1]封装概述
•是指隐藏对象的属性和实现细节，仅对外提供公共访问方式。
- 好处：
•隐藏实现细节，提供公共的访问方式
•提高了代码的复用性
•提高安全性。
- 封装原则：
•将不需要对外提供的内容都隐藏起来。
•把属性隐藏，提供公共方法对其访问。
[n2]不会报错,因为不写，系统会赠送一个无参构造
[n3]使用super关键字
[n4]会调用子类自己的
[n5](其实这个算不上方法重写，但是现象确实如此，至于为什么算不上方法重写，多态中我会讲解)
腾讯云开发者
