08-面向对象三大特征

最新推荐文章于 2025-02-06 09:09:02 发布
原创 最新推荐文章于 2025-02-06 09:09:02 发布 · 246 阅读 · 0 ·
本内容遵循CC 4.0 BY-SA版权协议
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
收录于
Java基础

当前文章被收录于：

Java基础
20 篇文章 1 人学习

Java基础知识

订阅专栏 查看详情

引言

前面的章节咱们掌握了，面向对象的基本使用，除此以外，面向对象思想还具备三大典型特征，分别是封装 继承和多态，面向对象的三大特征，就是面向对象思想的核心，使用这三特征，可以设计更为安全，简洁，灵活的程序。

一. 封装

1.1 封装概念

封装的意思，广义的封装，指的是把物体装起来，例如CPU的封装技术，在编程语言中的封装，往往指的是，把数据有效保护起来，对其访问设定限制，达到保护数据，使数据不被破坏，达到数据安全的目的。
image.png

1.2 实现封装

Java中实现封装是通过 private 关键字实现， private 意为私有的意思，指的是如果一个属性 或者 方法被其修饰，那么这个属性和方法就只能在其声明的类中使用。

语法：

class Foo{
   private int age;
    
   public void aa(){
   
   }

}

class TestFoo{
 
    public static void main(String[] args){
    
        Foo foo = new Foo();
        foo.age=100; //报错,此时age是无法被访问的。 
    }
}

1.3 访问被私有化属性

一个属性被私有化以后，出了本类的其他地方，都无法访问，这是，如果外界有需要对其访问，咱们可以提供 数据访问的方法，如果要取值提供get方法，如果要赋值提供set方法，如果都需要，则都提供。

class Foo{
   private int age;
   public int getAge(){       // 取值方法
      return this.age;
   } 
   public int setAge(int age){// 赋值方法
      this.age = age;
   } 
}

这里的取值 设值 方法都是有行规的 set+属性(首字母大写) get+属性名(首字母大写) ， 事实上这个规范称为 JavaBean 规范。

设计模式：23个

二. 继承

继承，来源于生活，生活中继承，是指后代获得父辈的资产，通过继承，后代可以获得这些资源而无需重复创造，得利得是后代。这种思想，在编程中也成立，在编程中，后代获得的是父辈定义的属性和行为，可以理解是代码的继承。
image.png

2.1 父类建立

继承是两个类的事情，要使用继承特性，首先需要分析出父子类，父类的抽取是关键，父类于子类通常存在一种关系，就是 is-a ** 的关系，描述为是一种的关系，比如 狗是一种动物， 汽车是一种交通工具，等等 ，当然，这里对父类的抽取也需要把握度，也往上越抽象， 父类的作用就是定义子类需要的属性和行为，也叫共性 ，**差异部分，需要子类自己定义。
image.png

2.2 继承语法

继承的语法关键字为 extends , 子类名 extends 父类名。

class Animal{

}

class Dog extends Animal{
   
}

一个类如果没有显示继承任何父类，那么默认继承Object

2.3 继承特点

避免 多继承 c++ 类都了可能会出现 环形集成
Java中的继承为单继承，也就是一个类最多只有一个直接父类，但可以多级继承，同样可以为子类扩充更多的属性和方法。
image.png

2.4 不可继承

子类继承父类，并不是所有父类的东西都可继承。

  1. **构造器不可继承 **（构造器名字必须和类名一致）
  2. 私有化的属性不可继承（只有本类使用）private
  3. 默认属性 跨包不可继承（default 为同包访问级别）

继承练习

/**
 *
 *  动物：Animal
 *    [  属性 ]  颜色  年龄
 *    [  方法 ]  eat()吃  睡 sleep()
 *
 *
 *  狗 Dog
 *    [属性]   名字
 *    [方法]   lookDoor()
 *
 *
 *  猴  Monkey
 *    [属性]   无新增
 *    [方法]   play()
 *
 *  猪 Pig
 *    [属性]   体重
 *    [方法]   cross()
 *
 *
 *
 *  实例化动物调用方法。
 *
 *
 */

image.png

2.5 访问修饰符

image.png

从宽到严 public protected default private

总结： 子类的属性和方法，有自己特有的 叠加上 从父类继承来。

选择修饰符的经验： 属性在没有明确要求的情况下 ** private 方法在没有说明的情况下使用 public 务必要子类继承到的属性和方法使用 protected**

定义属性 用private 所有类 和 方法 public

思考：类 可以用 private？ 类不能用private

2.6 方法重写[多态灵活性的基础]

面向对象的编程语言中，子类可继承父类中的方法，而不需要重新编写相同的方法。但有时子类继承来的方法并不适用，而是想作一定的修改，这就需要采用方法的重写。方法重写又称方法覆盖。

image.png
1.发生方法重写的两个方法返回值、方法名、参数列表必须完全一致(子类重写父类的方法)。
2.子类抛出的异常下不能超过父类相应方法抛出的异常(子类异常不能大于父类异常)。
3.子类方法的访问级别不能低于父类相应方法的访问级别(子类访问级别不能低于父类访问级别)。

@Override 它是一个注解，用来检验方法是否重写正确。它不是必要的，建议加上防止重写错误。

public class Animal {
      protected String name;
      protected int age;
      protected String sex;

    public Animal(){

    }
    public Animal(String name, int age, String sex) {
        this.name = name;
        this.age = age;
        this.sex = sex;
    }

    public  void eat(){
        System.out.println("吃");
    }
    public  void sleep(){
        System.out.println("睡");
    }
}

public class Dog extends  Animal{

    //共性属性和方法无需定义了，继承就可以了

    //子类特有的属性和行为
    String color;

    public void lookDoor(){
        System.out.println("看门");
    }

    //重新继承的方法
    @Override
    public void eat() {
        System.out.println("吃骨头");
    }

    @Override
    public void sleep() {
        System.out.println("躺着睡");
    }
}

2.7 对象创建过程

如果引入继承后，子类的创建过程会导致相关父类初始化而触发相关父类的构造器执行。具体过程是，先分配子类对象所需实例空间，然后依次递归调用父级的方法初始化属性。

方法的作用是初始化对象的方法。一般通过new 创建对象 则会触发。

  1. 分配子类所需的空间（自己实例属性空间和 父类继承实例空间）
  2. 递归调用父级的方法（ 属性的赋值+构造器的执行 ）
  3. 递归返回，完成自己的初始化方法( 属性的赋值+构造器的执行 )
class Super{
    String sex = "男";  //1
    public Super(){
        System.out.println("Super()");//2
    }
}
class Father extends Super{

    String name="admin";//3

    public Father(){
        System.out.println("Father()");//4
    }
}
class Son extends Father{

    int age=19;//5

    public Son(){
        System.out.println("Son()");//6
    }

}
public class ObjectCreateDemo {

    public static void main(String[] args) {

        Son son = new Son();
    }
}

2.8 Super关键字

  1. super 可以访问到父类中声明的属性和方法。
/**
 * 理解Super的作用
 */
public class SuperDemo {

    public static void main(String[] args) {
        Son son = new Son();
        son.happy();
    }

}
class Father{
    String  name="张飞";
    int age;
    public void happy(){
        System.out.println("打麻将.....");
    }

}

class Son extends Father{
    String hobby;
    String name="刘备";
    @Override
    public void happy() {
        super.happy();
        System.out.println("蹦迪......"+super.name);
    }
}

如果子类 存在方法重写 和 属性遮蔽 ， 可以通过 super.xxx 来强制区分。

  1. super 可以调用父类的构造器。
class Father{
    String  name;
    int age;

    public Father(String name, int age) {
        this.name = name;
        this.age = age;
    }

    public void happy(){
        System.out.println("打麻将.....");
    }

}
class Son extends Father {

    String hobby;
    public Son(String hobby,String name, int age){
        super(name,age);// 调用父类构造器
        this.hobby=hobby;
    }

    @Override
    public void happy() {
        System.out.println("蹦迪......");
    }
}

三. 多态

指的的是 一个对象的多种状态，不同状态下，具有不同的行为。从语法角度讲，就是 父类的引用可以指向任意子类对象。

3.1什么是多态

从语法上讲，就是 通过_父类类型的引用保存子类对象_，通过不同父类调用不同的行为。通过父类只能调用父类中声明的属性和方法，无法调用子类特有的属性和方法。
image.png
这里 lookdoor()就是子类特有的方法。

//动物：父类
public class Animal {

    public void eat(){
        System.out.println("eat()");
    }
    public void sleep(){
        System.out.println("sleep()");
    }
    public void shit(){
        System.out.println("shit()");
    }
}

//Dog 子类
public class Dog extends Animal {

    @Override
    public void eat() {
        System.out.println("啃着吃....");
    }

    @Override
    public void sleep() {
        System.out.println("躺着睡....");
    }

    @Override
    public void shit() {
        System.out.println("找个电线杆尿....");
    }
    
    
    //特有方法
    public void  lookDoor(){
        System.out.println("看门.....");
    }

}



// Cat 子类
public class Cat extends Animal {

    public void eat(){
        System.out.println("吃鱼");
    }
    public void sleep(){
        System.out.println("上树睡觉");
    }
    public void shit(){
        System.out.println("猫砂盆里尿");
    }

    //特有方法
    public void catchMouse(){
        System.out.println("捉老鼠");
    }

}

public class Test {
    public static void main(String[] args) {
        Animal obj = new Dog(); // 这里为多态
        obj.eat();
        obj.shit();
        obj.sleep();
        //obj.lookDoor();
        //obj.catchMouse();
    }
}

3.2多态中的重写

多态语法中，通过父类的引用去调用方法，分情况讨论，如果这个方法被子类重写过，那么调用子类重写的方法，如果子类没有重写，调用父类中的方法。多态语法可以记一个口诀： 编译看左边(能调用什么东西)，运行看右边(实际运行的是谁)。

public class Test {
    public static void main(String[] args) {
        Animal obj = new Cat();
        obj.eat();
        obj.shit();
        obj.sleep();
        //obj.lookDoor();  报错
        //obj.catchMouse(); 报错
        //解释： 这里 obj 是Animal 类型的引用只能调用 Animal 声明的方法， 而注释掉的方法属于子类的特有方法。
    }
}

3.3 类型转换

// 自动类型提升 : 安全 自动完成
Animal an = new Cat();
// 向下转型 ： 不安全 手动完成
Dog dd  = (Dog)an; //java.lang.ClassCastException: case6.Cat cannot be cast to case6.Dog
dd.lookDoor();

3.4 instanceof 关键字

作用是判断一个引用是否为指定的类型 语法为 引用 instanceof 类型 如果该表达式成立返回 true ，否则返回false

 public static void main(String[] args) {
        System.out.println("--------转型-----------");
        // 自动类型提升 : 安全 自动完成
        Animal an = new Dog();
        // 向下转型 ： 不安全 手动完成
        //Dog dd  = (Dog)an; //java.lang.ClassCastException: case6.Cat cannot be cast to case6.Dog
        //dd.lookDoor();
        // 转型前判断一下
         an.Animal中声明的方法

             
        if( an instanceof Cat  ){
             Cat xx= (Cat)an;
             xx.catchMouse();
        }
     
     
        if( an instanceof  Dog ){
            Dog yy = (Dog)an;
            yy.lookDoor();
        }
     
 }

3.5 多态应用场景

  1. 父类类型做参数
//主人
public class Master {
    /* 这两个方法重载，可以使用多态优化为一个方法
    //接收一个 Dog 类型的参数
    public void  feed( Dog obj  ){
        obj.eat();
    }
    //接收一个 Cat 类型的参数
    public void  feed( Cat obj  ){
        obj.eat();
    }
    */
    //接收一个 Animal 类型的参数
    public void  feed( Animal obj  ){ //Animal obj = cat = new Cat();
        obj.eat();
    }
    public static void main(String[] args) {
        Dog dog = new Dog();
        Cat cat = new Cat();
        Master master = new Master();
        master.feed(  cat  ); // 这里可以传  cat 和  dog对象 均可。
    }

}
  1. 父类型做返回值
//主人
public class Master {
    //接收一个 Animal 类型的参数
    public void  feed( Animal obj  ){
        obj.eat();
    }

    //返回值为父类类型
    public  Animal  kill(){
        Random random = new Random();
        int num = random.nextInt(2);
        if( num == 0 ){ //杀个狗
            Dog dog = new Dog();
            return dog;
        }else{ //杀个猫
            Cat cat = new Cat();
            return cat;
        }
    }
  
}

3.父类型定义数组，可以保存各种子类对象

    public static void main(String[] args) {
        Animal[] arr = new Animal[4];
        arr[0] = new Cat();
        arr[1] = new Dog();
        arr[2] = new Cat();
        arr[3] = new Dog();
        for( Animal an : arr){
            an.eat();
        }
    }

4. 类与类的关系

4.1 什么是依赖

比如A类使用B类，就是说明A是依赖于B的，通常依赖存在一下集中情况。

4.2 聚合

一个类A的属性是另一个B类型，B类型的这个属性就是聚合属性。
私家车案例

public class Car  {

    private String brand;

    public Car() {
    }

    public Car(String brand) {
        this.brand = brand;
    }

    public void run(){
        System.out.println(brand+"行驶....");
    }

    public String getBrand() {
        return brand;
    }

    public void setBrand(String brand) {
        this.brand = brand;
    }
}

public class Person {
    private String name;
    //存在一个属性
    private Car myCar;

    public Person() {

    }

    public Person(String name, Car myCar) {
        this.name = name;
        this.myCar = myCar;
    }

    //开车方法
    public void drive(){
        //无需外接提供汽车，自己都有
        this.myCar.run();
    }

    public String getName() {
       
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public Car getMyCar() {
        
        return myCar;
    }

    public void setMyCar(Car myCar) {
        this.myCar = myCar;
    }
}

4.3 参数依赖

一个方法的参数是另一个B类型，这样就是方法依赖某个类型。
代驾案例

 
public class Person {
    
    private String name;

    public Person() {

    }
    public Person(String name) {
        this.name = name;

    }
    //开车方法
    public void drive( Car car ){
        //需要外部传入一个汽车对象
        car.run();
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }
}

4.4 继承

继承在本章节中，已经重点讨论过了，如果一个类需要使用其他类的功能，继承也是一种方案，通过继承其他类，来获得其他类的行为，但是这种情况，通常是自己和继承的其他类是同一种事物。这种耦合对是非常高的，一般不继承，就不要轻易继承，继承是一种侵入式的编程方式。
汽车人案例

public class Car {

    private String brand;

    public Car() {
    }

    public Car(String brand) {
        this.brand = brand;
    }

    public void run(){
        System.out.println(brand+"行驶....");
    }

    public String getBrand() {
        return brand;
    }

    public void setBrand(String brand) {
        this.brand = brand;
    }
}

public class Person extends Car {
    private String name;

    public Person() {

    }
    public Person(String name) {
        this.name = name;

    }
    //开车方法
    public void drive(   ){
        //无需外接提供汽车，自己从父类继承了行驶方法
        this.run();
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }
}

软件设计遵循的一个原则高内聚 低耦合。
关于耦合度高低： 参数耦合 < 属性聚合 < 继承。

标签
#java #算法 #开发语言
Java中面向对象编程
weixin_44482920的博客
11-21 226
面向对象编程 面向对象编程基本可分为包，集成，组合，多台，抽象类，接口。 1.包是组织类的一种方式，使用包的主要目的是保证类的唯一性。 (1)导入包中的类 public class Test { public static void main(String[] args) { java.util.Date date = new java.util.Date(); ...
java中的继承——父类与子类的关系
Loobeeke的博客
03-24 1万+
父类引用指向子类对象时
面向对象编程
Fighting261的博客
05-11 480
继承 代码中创建的类, 主要是为了抽象现实中的一些事物(包含属性和方法). 有的时候客观事物之间就存在一些关联关系, 那么在表示成类和对象的时候也会存在一定的关联. 例如, 设计一个类表示动物 public class Animal { public String name; public Animal(String name) { this.name = name; } public void eat(String food) { System.out.println(this.name
Java基础编程之面向对象三大特征
weixin_50522909的博客
09-17 277
面向对象三大特征 一、封装 1、封装性的体现： 1）、狭义上体现： ①私有化（private）类的属性xxx，同时，提供公共的（public）设置（setXxx（））和获取（getXxx（））的方法； ②如果类中的方法，不希望在类外被调用，我们可以设置为private的； ③如果类A不希望在本包之外被调用，那么可以将此类A声明为缺省的； ①单例模式： 如果枚举类的对象只有一个，可以看成单例模式的实现方式 //枚举类单例模式的实现 class enum Person{ MAM； priv
Java中面向对象三大特性及其各自的用处
m0_46339652的博客
04-26 3327
Java中面向对象三大特性及其各自的用处：封装，继承，多态 一.封装： 封装把客观事物封装成抽象的类，并且类可以把自己的数据和方法只让可信的类或者对象操作，对不可信的进行信息隐藏，这就是封装。封装是面向对象的特征之一，是对象和类概念的主要特性。 简单的说，一个类就是一个封装了数据以及操作这些数据的代码的逻辑实体。在一个对象内部，某些代码或某些数据可以是私有的，不能被外界访问。通过这种方式，对象对内部数据提供了不同级别的保护，以防止程序中无关的部分意外的改变或错误的使用了对象的私有部分。 二.继承 继承是从已
08-面向对象的三大特征
2401_88421626的博客
10-24 881
(4) 注意： a. 如果 子类的方法名、形参列表和父类相同，但是返回值类型不同，编译报错。III. this()/this(实参) 和 super()/super(实参) 不能同时定义在一个构造方法中 Iv. 如果子类的构造方法的第一行语句为 this()/this(实参)，则JVM完成父类创建时不在当前的子类 的构造方法第一行语句查找 super()/super(实参) ，而是转向 this()/this(实参)指向的构造方法 的第一行查找super()/super(实参)。
day08-面向对象三大特征
jsh666的博客
07-12 114
尽可能隐藏对象的内部实现细节，控制对象的修改及访问的权限。访问修饰符：private。 以访问方法的形式，进而完成赋值与取值操作。提供公共访问方法，以保证数据的正常录入。 JavaBean 分为两种：1、数据承载Bean：私有化属性，对外提供公共的set、get方法，提供有参无参构造 2、业务逻辑Bean两个类之间的继承关系，必须满足“is a”的关系。根据程序需要使用到的多个具体类，进行共性抽取，进而定义父类。父类引用指向子类对象，从而产生多种形态。这里在循环内创建了WifeManage对象，所以每次在
java基础08——面向对象三大特征 封装继承多态
最新发布
后端小白个人学习记录
02-06 247
封装是指把一个对象的状态信息（也就是属性）隐藏在对象内部，不允许外部对象直接访问对象的内部信息。但是可以提供一些可以被外界访问的方法来操作属性。就好像我们看不到挂在墙上的空调的内部的零件信息（也就是属性），但是可以通过遥控器（方法）来控制空调。如果属性不想被外界访问，我们大可不必提供方法给外界访问。但是如果一个类没有提供给外界访问的方法，那么这个类也没有什么意义了。就好像如果没有空调遥控器，那么我们就无法操控空凋制冷，空调本身就没有意义了（当然现在还有很多其他方法 ，这里只是为了举例子）。
【JavaSE】【面向对象08】面向对象三大特征---继承
weixin_43589563的博客
12-30 199
面向对象的基本特征之二：继承Inheritance 1、为什么要有继承？ 当多个类中存在相同属性和行为时，将这些内容抽取到单独一个类中，那么多个类无需再定义这些属性和行为，只要继承那个类即可。提高了代码的复用性。 继承的出现让类与类之间产生了关系，可以创建更为特殊的类型。 利于可维护性。 此处的多个类称为子类（派生类SubClass），单独的这个类称为父类（基类或超类SuperClass）。 可以理解为:“子类 is a 父类” 2、如何继承？ 类继承语法规则：class Subclass
日常学习 8.08 Java面向对象三大特征之 多态
m0_57288002的博客
08-08 73
心得：忘记加关键字了，平白无故浪费好多时间，而且代码量变多，对需要的数据的类型判断出现差错，需要多加练习。-水根据不同温度条件，产生不同形态。3.当方法返回值的类型是父类的类型时，所有的子类对象都能返回出来。一个父类根据使用不同的子类对象，调用同样的方法，产生不同的结果。2.当方法的形式参数是父类的类型时，所有的子类对象都能传进来。满足以上三个条件的基础上，调用同一个方法，产生不同的结果。总结：一件事根据不同的环境条件，产生不同的 结果/形态。1.当数组的类型是父类的类型时，所有子类都能存入数组中。
#码神心得_08# 面向对象三大特征——封装、继承、多态
Red_xin的博客
06-17 1222
封装、继承、多态 面向对象的三大特征：封装、继承、多态，对于之前的我来说一直是很模糊的概念，直到余老师的讲解，终于有了较为深入的理解。 一、封装         顾名思义，“封装”就是把某些“东西”的具体“细节”封装隐藏起来，不让其他无关的“事物”随便动用，只留出“公用”部分与外界发生联系。比如说：一台手机，只提供屏幕的接触功能和按键功能供你操作，而手机内部的所有细小
Java面向对象编程三大特征 - 封装
热门推荐
微光点亮星辰
03-25 1万+
本文关键字：Java、面向对象、三大特征、封装。封装是面向对象编程中的三大特征之一，在对封装性进行解释时我们有必要先了解一些面向对象的思想，以及相关的概念。
08_面向对象的三大特性
m0_45044194的博客
07-07 234
百知教育 - 孙帅 - 08_面向对象的三大特性 01_封装 概念： 尽可能 隐藏 对象内部实现细节，控制 对象的修改及访问的 权限。 访问修饰符： private（可将属性修饰为 私有 ，仅本类可见） 公共访问方法： 作用： 提供公共访问方法，以保证数据的 正常录入。 命名规范： 赋值：setXXX() //使用方法返回值实现赋值 取值：getXXX() //使用方法返回值实现取值...
JavaL1-08_面向对象思想
m0_72540399的博客
08-11 762
Java语言是一种面向对象的程序设计语言，而面向对象思想是一种程序设计思想，我们在面向对象思想的指引下，使用Java语言去设计，开发计算机程序，这里的对象泛指显示中一切事物，每种事物都具备自己的属性和行为，行为特征抽象出来。描述成计算机事件的设计思想。它区别于面向过程思想，强调的是通过调用对象的行为来实现功能，而不是自己一步一步的去操作实现。类：是一组相关属性和行为的集合。可以看成是一类事物的模板，使用事物的属性特征和行为特征来描述该类事物。属性：就是该事物的状态信息。行为：就是该事物能够做什么。
Java中面向对象三大特征
weixin_30302609的博客
07-10 87
也就是说在这里"人"是多态的, 在不同的形态时,特征行为是不一样的, 这里的"人", 同时有两种形态,一种是教师形态,一种是学生形态,所对应的特征行为分别是"授课"与"做作业". Java中面向对象三大特征 2012-02-10 00:12 提问者： 匿名 等4人 如题！ 我来帮他解答 网友推荐答案 2011-08-06 23:36taotling|当前分类：1...
java面向对象三大特征
weixin_64689713的博客
08-18 799
Java面向对象的三个基本特征是封装、继承和多态。封装可以将数据和方法包装在一个单独的单元中，从而实现数据的隐藏和方法的封装；继承允许我们通过定义一个新的类来扩展一个已有的类，从而实现代码的复用；多态允许我们在不知道具体类型的情况下，使用父类的引用来引用子类的对象，从而实现代码的灵活性和可扩展性。掌握这三个基本特征，可以让我们更好地理解和应用Java面向对象编程的思想和方法。
【Java】面向对象的三大特征：封装、继承、多态
yican2580的博客
06-01 3378
本章详细解析了Java面向对象编程中的三大特性：封装、继承、多态
面向对象编程的三大特征是什么？
weixin_56187723的博客
08-10 475
运行时多态性则主要通过方法覆盖（Override）和接口实现来实现，即子类可以覆盖父类的方法，并且可以通过父类的引用来调用子类覆盖后的方法。多态性增强了程序的灵活性和可扩展性，使得程序更加动态和易于维护。子类可以拥有父类的所有属性和方法（除非它们被声明为private），同时子类还可以添加新的属性和方法或覆盖（Override）继承来的方法。它指的是将对象的属性和方法（或称为行为）结合在一起，形成一个独立的单元，并尽可能隐藏对象的内部细节（即将数据隐藏起来），只对外公开接口（即对象的方法）。
Java---面向对象编程的三大特征
wjj20040809的博客
05-19 455
设计一个动物类(Animal)，有一个move()，再写三种动物，Bird，Snake，Fish。private < 默认(不写)：本包 < protected(继承) < public。1.父类引用指向子类对象 Animal a = new Dog();~ 类，不能不被实例化 AbstractA a = new 子类();在一个类中，方法名称完全一样，参数的类型或者个数不一样。实际上没有多大作用，被子类的方法重写。protected --继承(包)java的继承---》单继承，
面向对象三大特征
weixin_45846105的博客
01-19 197
面向对象三大特征。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值