封装、继承、多态【下】

简介: 封装 程序设计要高内聚,低耦合 封装(数据的隐藏) 通常应禁止直接访问一个对象中数据的实际表示,而应该通过操作接口来访问,这称为信息隐藏 属性私有,get/set public static void main(String[] args) { Student s1 = new Student();

封装、继承、多态


多态


  • 动态编译:类型:可扩展性更强


  • 同一方法可以根据发送对象的不同而采用多种不同的行为方式


  • 一个对象的实际类型是确定的,但可以指向对象的引用的类型有很多(父类,有关系的类)


  • 多态存在的条件


  • 有继承关系


  • 子类重写父类方法


  • 父类引用类型指向子类对象


  • 多态是方法的多态,属性没有多态性


  • 多态的注意事项:1.多态是方法的多态,属性没有多态2.父类和子类,有联系 类型转换异常 ClassCastException3.存在的条件:继承关系,方法需要重写,父类引用类型指向子类对象 Father f1 = new Son();不能被重写的方法:


  1. static 方法,属于类,它不属于实例
  2. final 常量
  3. private 方法


  • instanceof (类型转换)引用类型


public class Student extends Person{
    @Override
    public void run() {
        System.out.println("son");
    }
    public void eat(){
        System.out.println("eat");
    }
}
=======================================================
public class Person {
    public void run(){
        System.out.println("run");
    }
}
=======================================================
import com.oop.demo06.Person;
import com.oop.demo06.Student;
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();
        s2.run();//子类重写了父类的方法,执行子类的方法
        s1.run();
        //对象能执行哪些方法,主要看对象左边的类型,和右边关系不大!
        s1.eat();
        ((Student) s2).eat();   //Person类型转换为Student类型
    }
}


  • instanceof的使用


public class Teacher extends Person{
}
===================================================================
public class Student extends Person{
    public void go(){
        System.out.println("go");
    }
}
===================================================================
public class Person {
    public void run(){
        System.out.println("run");
    }
}
===================================================================
import com.oop.demo06.Person;
import com.oop.demo06.Student;
import com.oop.demo06.Teacher;
public class Application {
    //Object > String
    //Object > Person > Teacher
    //Object > Person > Student
    public static void main(String[] args) {
        Object object = new Student();
        //System.out.println(X instanceof Y);   //X的引用类型与Y存在父子关系才能编译通过
        //引用类型 X 指向的实际对象与 Y 有父子关系才会报true
        System.out.println(object instanceof Student); //true
        System.out.println(object instanceof Person); //true
        System.out.println(object instanceof Object); //true
        System.out.println(object instanceof Teacher); //false
        System.out.println(object instanceof String); //false
        System.out.println("========================================");
        Person person = new Student();
        System.out.println(person instanceof Student); //true
        System.out.println(person instanceof Person); //true
        System.out.println(person instanceof Object); //true
        System.out.println(person instanceof Teacher); //false
        //System.out.println(person instanceof String); //编译报错,无直接上下级关系时就会报错
        System.out.println("========================================");
        Student student = new Student();
        System.out.println(student instanceof Student); //true
        System.out.println(student instanceof Person); //true
        System.out.println(student instanceof Object); //true
        //System.out.println(student instanceof Teacher); //编译报错
        //System.out.println(student instanceof String); //编译报错
    }
}


  • 父类与子类引用类型转换


  • 引用类型转换:


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


2.把子类转换为父类,向上转型,不用强制转换,可能会丢失一些方法


3.把父类转换为子类,向下转型,强制转换


4.方便方法的调用,减少重复代码!简洁


import com.oop.demo06.Person;
import com.oop.demo06.Student;
public class Application {
    public static void main(String[] args) {
        //类型之间的转换:基本类型转换    高-》低     强制转换
        //高                低    (父->子)
        Person obj = new Student();
        //student将这个对象转换为Student类型,我们就可以使用Student类型的方法了
        ((Student) obj).go();
        //子类转换为父类(不需强制转换),可能丢失自己的本来的一些方法
        Student student = new Student();
        student.go();
        Person person = student;//Student类型转换为Person类型
        //person.go();编译报错
    }
}


相关文章
|
17天前
抽象类和接口在实现多态时的区别
【10月更文挑战第19天】抽象类和接口在实现多态时都有其独特的作用。抽象类更适合用于定义一些具有共同特征和部分实现的类,而接口则更强调定义一组行为规范,以便不同的类可以实现并组合这些行为。
50 10
|
2月前
|
Java 编译器
封装,继承,多态【Java面向对象知识回顾①】
本文回顾了Java面向对象编程的三大特性:封装、继承和多态。封装通过将数据和方法结合在类中并隐藏实现细节来保护对象状态,继承允许新类扩展现有类的功能,而多态则允许对象在不同情况下表现出不同的行为,这些特性共同提高了代码的复用性、扩展性和灵活性。
封装,继承,多态【Java面向对象知识回顾①】
|
6月前
|
C++
C++中的封装、继承与多态:深入理解与应用
C++中的封装、继承与多态:深入理解与应用
144 1
|
4月前
|
Java 编译器
Java面向对象(三)详解: 封装 | 继承 | 方法重写 | 抽象类
Java面向对象(三)详解: 封装 | 继承 | 方法重写 | 抽象类
|
Java
1.8 封装、继承、多态
1.8 封装、继承、多态
41 1
|
Java
面向对象编程基础:类、对象、封装、继承和多态
面向对象编程基础:类、对象、封装、继承和多态
108 0
|
设计模式
从“封装、继承、多态”看构建知识网
从“封装、继承、多态”看构建知识网
59 0
面向对象的封装,继承,多态(一)
面向对象的封装,继承,多态。
80 0
面向对象的封装,继承,多态(一)