Java面向对象（2）封装继承多态

目录

 

封装

1、封装的步骤

2、作用和意义

3、方法重载

继承

1、继承

2、Object类

3、Super关键字

4、方法重写

多态

1、什么是多态

2、重写、重载和多态的关系

3、多态的注意事项

4、多态存在的条件

5、方法绑定

6. 类型转换

 

---

封装

通俗地讲：该露的露，该藏的藏
专业地讲：我们程序设计要追求“高内聚，低耦合”。高内聚就是类的内部数据操作细节自己完成，不允许外部干涉；低耦合：仅暴露少量的方法给外部使用。
封装（数据的隐藏）
在定义一个对象的特性的时候，有必要决定这些特性的可见性，即哪些特性对外部是可见的，哪些特性
用于表示内部状态。
通常，应禁止直接访问一个对象中数据的实际表示，而应通过操作接口来访问，这称为信息隐藏。

1、封装的步骤

1. 使用private 修饰需要封装的成员变量。
2. 提供一个公开的方法设置或者访问私有的属性
设置 通过set方法，命名格式： set属性名（）; 属性的首字母要大写
访问 通过get方法，命名格式： get属性名（）; 属性的首字母要大写

//对象能在类的外部"直接"访问
public class Student{
public String name;
public void println(){
System.out.println(this.name);
}
}
public class Test{
public static void main(String[] args){
Student s = new Student();
s.name = "tom";
}
}

在类中一般不会把数据直接暴露在外部的,而使用private(私有)关键字把数据隐藏起来

public class Student{
private String name;
}
public class Test{
public static void main(String[] args){
Student s = new Student();
//编译报错,在类的外部不能直接访问类中的私有成员
s.name = "tom";
}
}

如果在类的外部需要访问这些私有属性,那么可以在类中提供对于的get和set方法,以便让用户在类的外部可以间接的访问到私有属性

//set负责给属性赋值
//get负责返回属性的值
public class Student{
private String name;
public void setName(String name){
this.name = name;
}
public String getName(){
return this.name;
}
}
public class Test{
public static void main(String[] args){
Student s = new Student();
s.setName("tom");
System.out.println(s.getName());
}
}

2、作用和意义

1. 提高程序的安全性，保护数据。
2. 隐藏代码的实现细节
3. 统一用户的调用接口
4. 提高系统的可维护性
5. 便于调用者调用。

良好的封装，便于修改内部代码，提高可维护性。
良好的封装，可进行数据完整性检测，保证数据的有效性。

3、方法重载

类中有多个方法,有着相同的方法名,但是方法的参数各不相同,这种情况被称为方法的重载。方法的重载可以提供方法调用的灵活性

查看println方法的重载

public class Test{
public void test(String str){
}
public void test(int a){
}
}

方法重载必须满足以下条件
1. 方法名必须相同
2. 参数列表必须不同(参数的类型、个数、顺序的不同)

3. 方法的返回值可以不同，也可以相同。

public void test(Strig str){}
public void test(int a){}
public void test(Strig str,double d){}
public void test(Strig str){}
public void test(Strig str,double d){}
public void test(double d,Strig str){}

在java中,判断一个类中的俩个方法是否相同,主要参考俩个方面:方法名字和参数列表

继承

继承的本质是对某一批类的抽象，从而实现对现实世界更好的建模。

第一好处：继承的本质在于抽象。类是对对象的抽象，继承是对某一批类的抽象。
第二好处：为了提高代码的复用性。
extands的意思是“扩展”。子类是父类的扩展。

目前已知JAVA中类只有单继承，没有多继承。 接口可以多继承！

1、继承

1. 继承是类和类之间的一种关系。除此之外,类和类之间的关系还有依赖、组合、聚合等。
2. 继承关系的俩个类，一个为子类(派生类),一个为父类(基类)。子类继承父类,使用关键字extends来表示。

public class student extends Person{
}

3. 子类和父类之间,从意义上讲应该具有"is a"的关系.

student is a person
dog is a animal

4. 类和类之间的继承是单继承

一个子类只能"直接"继承一个父类,就像是一个人只能有一个亲生父亲
一个父类可以被多子类继承,就像一个父亲可以有多个孩子

java中接口和接口之间,也可以继承,并且是多继承。

5. 父类中的属性和方法可以被子类继承
子类中继承了父类中的属性和方法后,在子类中能不能直接使用这些属性和方法,是和这些属性和方法原有的修饰符(public protected default private)相关的。
例如 :
父类中的属性和方法使用public修饰,在子类中继承后"可以直接"使用
父类中的属性和方法使用private修饰,在子类中继承后"不可以直接"使用
父类中的构造器是不能被子类继承的,但是子类的构造器中,会隐式的调用父类中的无参构造器(默认使用super关键字)。

2、Object类

java中的每一个类都是"直接" 或者 "间接"的继承了Object类.所以每一个对象都和Object类有"is a"的关系。从API文档中,可以看到任何一个类最上层的父类都是Object

System.out.println(任何对象 instanceof Object);
//输出结果:true
//注:任何对象也包含数组对象
例如:
//编译后,Person类会默认继承Object
public class Person{}
//Student是间接的继承了Object
public class Student extends Person{}

在Object类中,提供了一些方法被子类继承,那么就意味着,在java中,任何一个对象都可以调用这些被继承过来的方法。(因为Object是所有类的父类)
例如:toString方法、equals方法、getClass方法等

3、Super关键字

子类继承父类之后,在子类中可以使用this来表示访问或调用子类中的属性或方法,使用super就表示访问或调用父类中的属性和方法。

1. super的使用
访问父类中的属性

public class Person{
protected String name = "zs";
}
public class Student extends Person{
private String name = "lisi";
public void tes(String name)t{
System.out.println(name);
System.out.println(this.name);
System.out.println(super.name);
}
}

调用父类中的方法

public class Person{
public void print(){
System.out.println("Person");
}
}
public class Student extends Person{
public void print(){
System.out.println("Student");
}
public void test(){
print();
this.print();
super.print();
}
}

调用父类中的构造器

public class Person{
}
public class Student extends Person{
//编译通过,子类构造器中会隐式的调用父类的无参构造器
//super();
public Student(){
}
}

super使用的注意的地方
1. 用super调用父类构造方法，必须是构造方法中的第一个语句。
2. super只能出现在子类的方法或者构造方法中。
3. super 和 this 不能够同时调用构造方法。（因为this也是在构造方法的第一个语句）

super 和 this 的区别
1. 代表的事物不一样:
   this：代表所属方法的调用者对象。super：1代表父类对象的引用空间。

 2. 使用前提不一致：
 this：在非继承的条件下也可以使用。super：只能在继承的条件下才能使用。

3. 调用构造方法：
this：调用本类的构造方法。super：调用的父类的构造方法

4、方法重写

方法的重写（override）
1. 方法重写只存在于子类和父类(包括直接父类和间接父类)之间。在同一个类中方法只能被重载，不能被重写.
2. 静态方法不能重写

•  父类的静态方法不能被子类重写为非静态方法 //编译出错
•  父类的非静态方法不能被子类重写为静态方法；//编译出错
• 子类可以定义与父类的静态方法同名的静态方法(但是这个不是覆盖)

A类继承B类 A和B中都一个相同的静态方法test
B a = new A();
a.test();//调用到的是B类中的静态方法test
A a = new A();
a.test();//调用到的是A类中的静态方法test
静态方法的调用只和变量声明的类型相关
这个和非静态方法的重写之后的效果完全不同

重写的语法
1. 方法名必须相同
2. 参数列表必须相同
3. 访问控制修饰符可以被扩大,但是不能被缩小： public protected default private
4. 抛出异常类型的范围可以被缩小,但是不能被扩大ClassNotFoundException ---> Exception
5. 返回类型可以相同,也可以不同,如果不同的话,子类重写后的方法返回类型必须是父类方法返回类型的子类型
 总结：
方法重写的时候，必须存在继承关系。
方法重写的时候，方法名和形式参数 必须跟父类是一致的。
方法重写的时候，子类的权限修饰符必须要大于或者等于父类的权限修饰符。( private < protected <public，friendly < public )
方法重写的时候，子类的返回值类型必须小于或者等于父类的返回值类型。( 子类 < 父类 ) 数据类型没有明确的上下级关系
方法重写的时候，子类的异常类型要小于或者等于父类的异常类型。

多态

1、什么是多态

多态性是OOP中的一个重要特性，主要是用来实现动态联编的

1. 一个对象的实际类型是确定的

new Student(); new Person();

2. 可以指向对象的引用的类型有很多：例如: Student继承了Person类

Student s1 = new Student();
Person s2 = new Student();
Object s3 = new Student();

因为Person和Object都是Student的父类型

一个父类引用可以指向它的任何一个子类对象

Object o = new AnyClass();
Person p = null;
p = new Student();
p = new Teacher();
p = new Person();

多态中的方法调用

public class Person{
public void run(){}
}
public class Student extends Person{
}

调用到的run方法,是Student从Person继承过来的run方法

main:
Person p = new Student();
p.run();

2、重写、重载和多态的关系

重载是编译时多态

重写是运行时多态

3、多态的注意事项

1. 多态是方法的多态，属性没有多态性。
2. 编写程序时，如果想调用运行时类型的方法，只能进行类型转换。不然通不过编译器的检查。但是如果两个没有关联的类进行强制转换，会报：ClassCastException。
3. 多态的存在要有3个必要条件：要有继承，要有方法重写，父类引用指向子类对象

4、多态存在的条件

1. 有继承关系
2. 子类重写父类方法

•  static方法，因为被static修饰的方法是属于类的，而不是属于实例的
•  final方法，因为被final修饰的方法无法被子类重写
• private方法和protected方法，前者是因为被private修饰的方法对子类不可见，后者是因为尽管被protected修饰的方法可以被子类见到，也可以被子类重写，但是它是无法被外部所引用的

3. 父类引用指向子类对象

5、方法绑定

执行调用方法时，系统根据相关信息，能够执行内存地址中代表该方法的代码。分为静态绑定和动态绑定。
静态绑定：
在编译期完成，可以提高代码执行速度。
动态绑定：
通过对象调用的方法，采用动态绑定机制。这虽然让我们编程灵活，但是降低了代码的执行速度。这也是JAVA比C/C++速度慢的主要因素之一。

JAVA中除了final类、final方、static方法，所有方法都是JVM在运行期才进行动态绑定的。
多态：如果编译时类型和运行时类型不一致，就会造成多态。

6. 类型转换

public class Person{
public void run(){}
}
public class Student extends Person{
public void go(){}
}
public class Teacher extends Person{
}

为什么要类型转换

//编译报错,因为p声明的类型Person中没有go方法
Person p = new Student();
p.go();
//需要把变量p的类型进行转换
Person p = new Student();
Student s = (Student)p;
s.go();
或者
//注意这种形式前面必须要俩个小括号
((Student)p).go();