面向对象编程03：封装、继承、多态
面向对象编程03：封装、继承、多态
文章目录
- 面向对象编程03：封装、继承、多态
-
- 封装
- 继承
-
- object类
- super
-
- super注意点：
- `super` VS `this`:
- 方法重写
- 多态
-
-
- 多态的注意事项：
-
- instanceof关键字
- 父类与子类之间的类型转换
封装
- 该露的露、该藏的藏
- 设计程序要追求“高内聚、低耦合”。
- 高内聚就是类的内部数据操作细节由自己完成，不允许外部干涉；
- 低耦合：仅仅暴露少量的方法给外部使用。
- 封装（数据的隐藏）
- 通常我们应该禁止直接访问一个对象中数据的实际表示，而应该通过操作接口来访问，这被称为“信息隐藏”。
- 理解封装，记住这句话就够了：属性私有，get/set
下面我们来看看封装的代码实例：
public class Student {
//属性私有:private
private String name;//名字
private int id;//学号
private char sex;//性别
private int age;//年龄
//提供一些可以操作这个属性的方法：public的get、set方法
//Alt+Enter快捷创建get和set方法
//get 获得这个数据
//set 设置值
public void setName(String name) {
this.name = name;
}
public String getName() {
return this.name;
}
public int getAge() {
return age;
}
public void setAge(int age) {
if (age<0||age>120){
System.out.println("invalid number");
}else{
this.age= age;
}
}
}
public class Application {
public static void main(String[] args) {
Student student = new Student();
student.setName("David");//将David通过setName方法赋值给name.
System.out.println(student.getName());
student.setAge(20);
System.out.println(student.getAge());
}
}
输出结果：
David
20
封装的好处：
- 提高程序的安全性。保护数据
- 隐藏代码的实现细节
- 统一接口
- 增加了系统的可维护性
继承
- 继承的本质是对某一批类的抽象，从而实现对现实世界更好的建模。
- extends的意思是“扩展”。子类是父类的扩展。
- JAVA中类只有单继承，没有多继承！
- 继承是类与类之间的一种关系。除此之外，类和类之间的关系还有依赖、组合、聚合等。
- 继承关系的两个类：一个为子类（派生类），一个为父类（基类）。子类继承父类，使用关键字extends表示。
- 子类和父类之间从意义上讲应该具有“is a”的关系。
下面我们来看一个简单的继承的例子：
//Java中所有的类都默认直接或间接继承object类
//父类： Person
class Person /*extends object*/ {
int money = 10_000_000;
public void say(){
System.out.println("说了一句话");
}
}
//子类：Student
//继承了父类的所有方法
class Student extends Person {
}
public class Application {
public static void main(String[] args) {
Student student = new Student();
student.say();//say是父类Person的方法
System.out.println(student.money);//money是父类Person中的变量
}
}
object类
在Java中所有的类都默认直接或间接继承object类。
class Person /*extends object*/ {
}
java的Object类方法如下：
getClass方法
获取运行时类型,返回值为Class对象
hashCode方法
返回该对象的哈希码值，是为了提高哈希表的性能（HashTable）
equals方法
判断两个对象是否相等，在Object源码中equals就是使用去判断，所以在Object中equals是等价于的，但是在String及某些类对equals进行了重写，实现不同的比较。
clone方法
主要是JAVA里除了8种基本类型传参数是值传递，其他的类对象传参数都是引用传递，我们有时候不希望在方法里将参数改变，这时就需要在类中复写clone方法。
如果在clone方法中调用super.clone()方法需要实现Cloneable接口,否则会抛出CloneNotSupportedException。
此方法只实现了一个浅层拷贝,对于基本类型字段成功拷贝,但是如果是嵌套对象,只做了赋值,也就是只把地址拷贝了,所以没有成功拷贝,需要自己重写clone方法进行深度拷贝。
5.toString方法
返回一个String字符串,用于描述当前对象的信息,可以重写返回对自己有用的信息，默认返回的是当前对象的类名+hashCode的16进制数字。
wait方法
多线程时用到的方法，作用是让当前线程进入等待状态，同时也会让当前线程释放它所持有的锁。直到其他线程调用此对象的 notify() 方法或 notifyAll() 方法，当前线程被唤醒
notify方法
多线程时用到的方法，唤醒该对象等待的某个线程
notifyAll方法
多线程时用到的方法，唤醒该对象等待的所有线程
9.finalize
对象在被GC释放之前一定会调用finalize方法，对象被释放前最后的挣扎,因为无法确定该方法什么时候被调用，很少使用。
super
- super关键字指向父类：
//父类： Person
class Person {
int age = 60;
public void say(){
System.out.println("Person说了一句话");
}
}
//子类：Student
//继承了父类的所有方法
class Student extends Person{
public void print() {
System.out.println("Peosin is"+ super.age);
System.out.println("Student");
super.say();//
}
}
public class Application {
public static void main(String[] args) {
Student student = new Student();
student.print();
}
}
输出结果：
Person is 60
Student
Person说了一句话
- 调用子类构造器时相当于提前执行了一行隐藏代码：
super（）；：
//父类： Person
class Person {
public Person() {
System.out.println("Person无参构造已执行");
}
}
//子类：Student
//继承了父类的所有方法
class Student extends Person{
//super();
public Student() {
System.out.println("Student无参构造已执行");
}
}
/**
* @author 15065170282
*/
public class Application{
public static void main(String[] args) {
Student student = new Student();
}
}
输出结果：
Person无参构造已执行
Student无参构造已执行
super注意点：
super调用父类的构造方法，必须在构造方法的第一个；super只能出现在子类的方法或者构造方法中；super和this不能同时调用构造方法！
super VS this:
-
二者代表对象不同：
this: 代表调用者本身super: 代表父类应用 -
使用前提不同：
this: 不用继承就能直接使用super： 只能在继承条件下使用 -
构造方法：
this();代表本类的构造super();代表父类的构造
方法重写
-
前提：方法重写需要有继承关系，即子类重写了父类的***方法***，方法名、参数都一致但是方法体不同
-
方法重写只针对于实例方法,静态方法不存在重写
-
方法重写只针对于public关键字修饰的方法,private修饰的无法被继承
-
参数列表必须相同（不同就变成重载了）
-
修饰符：范围可以扩大但不能缩小： public>protected>default>private
-
抛出的异常范围可以被缩小但是不能扩大：
-
为什么需要重写？
因为有时父类的功能子类不一定需要或不一定满足；
-
快捷键（IDEA中）：
Alt + Insert
class Person{
public void say(){
System.out.println("父亲说了一句话");
}
}
class Student extends Person{
@Override
public void say() {
System.out.println("Student 重写了Person的方法");
}
}
/**
* @author 15065170282
*/
public class OverrideTest {
public static void main(String[] args) {
Person person = new Person();
person.say();
Student student = new Student();
student.say();
}
}
多态
- 同一方法可以根据发送对象的不同采取多种不同的行为方式。
- 一个对象的实际类型是确定的，但可以指向该对象的引用类型有很多
- 多态存在的条件：
- 有继承关系
- 子类重写父类方法
- 父类引用指向子类对象
下面来看一个多态的实例：
package JavaSe.oop.demo07;
class Person{
public void run(){
System.out.println("run");
}
}
class Student extends Person{
@Override
public void run() {
System.out.println("子类重写了父类的run方法");
}
public void eat(){
System.out.println("eat");
}
}
/**
* @ClassName Application
* @author 15065170282
**/
public class Application {
public static void main(String[] args) {
//一个对象的实现类是确定的：new Student(); new Person();
//但是引用类不能确定：父类的引用指向子类
//Student能调用的方法都是自己的或者是继承父类的！
Student s1 = new Student();
//Person父类可以指向子类但是不能调用子类独有的方法；
Person s2=new Student();
Object s3=new Student();
//对象能执行哪些方法取决于引用类的类型，和实现类无关；
s1.eat();
((Student) s2).eat();//类型转换
s1.run();
s2.run();
}
}
输出结果：
eat
eat
子类重写了父类的run方法
子类重写了父类的run方法
多态的注意事项：
-
多态指的是方法的多态，属性没有多态一说。
-
父类和子类因为有联系（继承关系）才能进行转换
类型转换异常：ClassCastException!
-
存在条件： 继承关系，方法需要重写，父类引用指向子类对象： Father F1 = new Son();
无法重写：
static方法，属于类，不属于实例；final常量；private方法；
instanceof关键字
instanceof 关键字用于判断两个类之间是否有父子关系。
public class InstanceOfTest {
public static void main(String[] args) {
//System.out.println(X instanceof Y);//能否编译通过取决于X与Y之间是否有关
//object-->Person-->Student
//object-->Person-->Teacher
Object o = new Object();
System.out.println(o instanceof Student);
System.out.println(o instanceof Person);
System.out.println(o instanceof Object);
System.out.println(o instanceof Teacher);
System.out.println(o instanceof String);
System.out.println("====================================");
Person person = new Person();
System.out.println(person instanceof Student);
System.out.println(person instanceof Person);
System.out.println(person instanceof Object);
System.out.println(person instanceof Teacher);
//编译时就会报错：System.out.println(person instanceof String);
System.out.println("====================================");
Student student = new Student();
System.out.println(student instanceof Student);
System.out.println(student instanceof Person);
System.out.println(student instanceof Object);
//编译时就会报错：System.out.println(student instanceof Teacher);
//编译时就会报错：System.out.println(student instanceof String);
}
}
输出结果：
false
false
true
false
false
====================================
false
true
true
false
====================================
true
true
true
父类与子类之间的类型转换
- 父类引用指向子类的对象： Father f = new Son();
- 子类转换成父类，向上转型；
- 父类转换成子类，向下转型：强制转换
- 作用：方便方法的调用，减少代码的重复
下面来看父子类类型转换的代码实例：
class Test{
}
class TestSon extends Test{
public void go(){
System.out.println("go");
}
}
/**
* @ClassName Application
* @Author ${17368877923}
**/
public class Application {
public static void main(String[] args) {
//类型之间的转化： 父 子
//高------>低需要强转
//低------>高可以直接转
Test test = new TestSon();
new TestSon().go();//对象.方法
//test.go();
TestSon testSon = (TestSon) test;
//可以对比int testSon=3; double test =3.0; int testSen=(int) test;高到低强转
// testSon将test对象转换为TestSon类型，我们就可以使用TestSon类型的方法了
testSon.go();
((TestSon) test).go();
}
}