封装，继承，多态

最新推荐文章于 2022-09-20 17:42:39 发布
最新推荐文章于 2022-09-20 17:42:39 发布
阅读量782 收藏 1
点赞数
文章标签： java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_46084827/article/details/124437813
版权

1. 封装

1.1 private关键字【理解】

private是一个修饰符，可以用来修饰成员（成员变量，成员方法）

  • 被private修饰的成员，只能在本类进行访问，针对private修饰的成员变量，如果需要被其他类使用，提供相应的操作

    • 提供“get变量名()”方法，用于获取成员变量的值，方法用public修饰

    • 提供“set变量名(参数)”方法，用于设置成员变量的值，方法用public修饰

  • 示例代码：

    /*
    学生类
 */
class Student {
    //成员变量
    String name;
    private int age;
​
    //提供get/set方法
    public void setAge(int a) {
        if(a<0 || a>120) {
            System.out.println("你给的年龄有误");
        } else {
            age = a;
        }
    }
​
    public int getAge() {
        return age;
    }
​
    //成员方法
    public void show() {
        System.out.println(name + "," + age);
    }
}
/*
    学生测试类
 */
public class StudentDemo {
    public static void main(String[] args) {
        //创建对象
        Student s = new Student();
        //给成员变量赋值
        s.name = "林青霞";
        s.setAge(30);
        //调用show方法
        s.show();
    }
}

1.2 private的使用【应用】

  • 需求：定义标准的学生类，要求name和age使用private修饰，并提供set和get方法以及便于显示数据的show方法，测试类中创建对象并使用，最终控制台输出  林青霞，30

  • 示例代码：

    /*
    学生类
 */
class Student {
    //成员变量
    private String name;
    private int age;
​
    //get/set方法
    public void setName(String n) {
        name = n;
    }
​
    public String getName() {
        return name;
    }
​
    public void setAge(int a) {
        age = a;
    }
​
    public int getAge() {
        return age;
    }
​
    public void show() {
        System.out.println(name + "," + age);
    }
}
/*
    学生测试类
 */
public class StudentDemo {
    public static void main(String[] args) {
        //创建对象
        Student s = new Student();
​
        //使用set方法给成员变量赋值
        s.setName("林青霞");
        s.setAge(30);
​
        s.show();
​
        //使用get方法获取成员变量的值
        System.out.println(s.getName() + "---" + s.getAge());
        System.out.println(s.getName() + "," + s.getAge());
​
    }
}

1.3 this关键字【应用】

  • this修饰的变量用于指代成员变量，其主要作用是（区分局部变量和成员变量的重名问题）

    • 方法的形参如果与成员变量同名，不带this修饰的变量指的是形参，而不是成员变量

    • 方法的形参没有与成员变量同名，不带this修饰的变量指的是成员变量

public class Student {
    private String name;
    private int age;
​
    public void setName(String name) {
        this.name = name;
    }
​
    public String getName() {
        return name;
    }
​
    public void setAge(int age) {
        this.age = age;
    }
​
    public int getAge() {
        return age;
    }
​
    public void show() {
        System.out.println(name + "," + age);
    }
}

1.4 this内存原理【理解】

  • this代表当前调用方法的引用，哪个对象调用的方法，this就代表哪一个对象

  • 示例代码

    public class StudentDemo {
    public static void main(String[] args) {
        Student s1 = new Student();
        s1.setName("林青霞");
        Student s2 = new Student();
        s2.setName("张曼玉");
    }
}

1.5 封装思想【理解】

  1. 封装概述 是面向对象三大特征之一（封装，继承，多态） 是面向对象编程语言对客观世界的模拟，客观世界里成员变量都是隐藏在对象内部的，外界是无法直接操作的

  2. 封装原则 将类的某些信息隐藏在类内部，不允许外部程序直接访问，而是通过该类提供的方法来实现对隐藏信息的操作和访问 成员变量private，提供对应的getXxx()/setXxx()方法

  3. 封装好处 通过方法来控制成员变量的操作，提高了代码的安全性 把代码用方法进行封装，提高了代码的复用性

2. 构造方法

2.1 构造方法概述【理解】

构造方法是一种特殊的方法

  • 作用：创建对象 Student stu = new Student();

  • 格式：

    public class 类名{

    修饰符 类名( 参数 ) {

    }

    }

  • 功能：主要是完成对象数据的初始化

  • 示例代码：

class Student {
    private String name;
    private int age;
​
    //构造方法
    public Student() {
        System.out.println("无参构造方法");
    }
​
    public void show() {
        System.out.println(name + "," + age);
    }
}
/*
    测试类
 */
public class StudentDemo {
    public static void main(String[] args) {
        //创建对象
        Student s = new Student();
        s.show();
    }
}

2.2 构造方法的注意事项【理解】

  • 构造方法的创建

如果没有定义构造方法，系统将给出一个默认的无参数构造方法 如果定义了构造方法，系统将不再提供默认的构造方法

  • 构造方法的重载

如果自定义了带参构造方法，还要使用无参数构造方法，就必须再写一个无参数构造方法

  • 推荐的使用方式

无论是否使用，都手工书写无参数构造方法

  • 重要功能！

可以使用带参构造，为成员变量进行初始化

  • 示例代码

/*
    学生类
 */
class Student {
    private String name;
    private int age;
​
    public Student() {}
​
    public Student(String name) {
        this.name = name;
    }
​
    public Student(int age) {
        this.age = age;
    }
​
    public Student(String name,int age) {
        this.name = name;
        this.age = age;
    }
​
    public void show() {
        System.out.println(name + "," + age);
    }
}
/*
    测试类
 */
public class StudentDemo {
    public static void main(String[] args) {
        //创建对象
        Student s1 = new Student();
        s1.show();
​
        //public Student(String name)
        Student s2 = new Student("林青霞");
        s2.show();
​
        //public Student(int age)
        Student s3 = new Student(30);
        s3.show();
​
        //public Student(String name,int age)
        Student s4 = new Student("林青霞",30);
        s4.show();
    }
}

2.3 标准类制作【应用】

  • 需求：定义标准学生类，要求分别使用空参和有参构造方法创建对象，空参创建的对象通过setXxx赋值，有参创建的对象直接赋值，并通过show方法展示数据。

  • 示例代码：

class Student {
    //成员变量
    private String name;
    private int age;
​
    //构造方法
    public Student() {
    }
​
    public Student(String name, int age) {
        this.name = name;
        this.age = age;
    }
​
    //成员方法
    public void setName(String name) {
        this.name = name;
    }
​
    public String getName() {
        return name;
    }
​
    public void setAge(int age) {
        this.age = age;
    }
​
    public int getAge() {
        return age;
    }
​
    public void show() {
        System.out.println(name + "," + age);
    }
}
/*
    创建对象并为其成员变量赋值的两种方式
        1:无参构造方法创建对象后使用setXxx()赋值
        2:使用带参构造方法直接创建带有属性值的对象
*/
public class StudentDemo {
    public static void main(String[] args) {
        //无参构造方法创建对象后使用setXxx()赋值
        Student s1 = new Student();
        s1.setName("林青霞");
        s1.setAge(30);
        s1.show();
​
        //使用带参构造方法直接创建带有属性值的对象
        Student s2 = new Student("林青霞",30);
        s2.show();
    }
}

3.API

3.1API概述【理解】

  • 什么是API

    API (Application Programming Interface) ：应用程序编程接口

  • java中的API

    指的就是 JDK 中提供的各种功能的 Java类，这些类将底层的实现封装了起来，我们不需要关心这些类是如何实现的，只需要学习这些类如何使用即可，我们可以通过帮助文档来学习这些API如何使用

4.String类

4.1String类概述【理解】

String 类代表字符串，Java 程序中的所有字符串文字（例如“abc”）都被实现为此类的实例。也就是说，Java 程序中所有的双引号字符串，都是 String 类的对象。String 类在 java.lang 包下，所以使用的时候不需要导包！

4.2String类的特点【理解】

  • 字符串不可变，它们的值在创建后不能被更改

  • 虽然 String 的值是不可变的，但是它们可以被共享

  • 字符串效果上相当于字符数组( char[] )，但是底层原理是字节数组( byte[] )

4.3String类的构造方法【记忆】

  • 常用的构造方法

    方法名说明
    public String()创建一个空白字符串对象，不含有任何内容
    public String(char[] chs)根据字符数组的内容，来创建字符串对象
    public String(byte[] bys)根据字节数组的内容，来创建字符串对象
    String s = “abc”;直接赋值的方式创建字符串对象，内容就是abc

  • 示例代码

    public class StringDemo01 {
    public static void main(String[] args) {
        //public String()：创建一个空白字符串对象，不含有任何内容
        String s1 = new String();
        System.out.println("s1:" + s1);
​
        //public String(char[] chs)：根据字符数组的内容，来创建字符串对象
        char[] chs = {'a', 'b', 'c'};
        String s2 = new String(chs);
        System.out.println("s2:" + s2);
​
        //public String(byte[] bys)：根据字节数组的内容，来创建字符串对象
        byte[] bys = {97, 98, 99};
        String s3 = new String(bys);
        System.out.println("s3:" + s3);
​
        //String s = “abc”; 直接赋值的方式创建字符串对象，内容就是abc
        String s4 = "abc";
        System.out.println("s4:" + s4);
    }
}

4.4创建字符串对象两种方式的区别【理解】

  • 通过构造方法创建

    通过 new 创建的字符串对象，每一次 new 都会申请一个内存空间，虽然内容相同，但是地址值不同

  • 直接赋值方式创建

    以“”方式给出的字符串，只要字符序列相同(顺序和大小写)，无论在程序代码中出现几次，JVM 都只会建立一个 String 对象，并在字符串池中维护

4.5字符串的比较【理解】

4.5.1==号的作用

  • 比较基本数据类型：比较的是具体的值

  • 比较引用数据类型：比较的是对象地址值

4.5.2equals方法的作用

  • 方法介绍

    public boolean equals(String s)     比较两个字符串内容是否相同、区分大小写

  • 示例代码

    public class StringDemo02 {
    public static void main(String[] args) {
        //构造方法的方式得到对象
        char[] chs = {'a', 'b', 'c'};
        String s1 = new String(chs);
        String s2 = new String(chs);

        //直接赋值的方式得到对象
        String s3 = "abc";
        String s4 = "abc";

        //比较字符串对象地址是否相同
        System.out.println(s1 == s2);
        System.out.println(s1 == s3);
        System.out.println(s3 == s4);
        System.out.println("--------");

        //比较字符串内容是否相同
        System.out.println(s1.equals(s2));
        System.out.println(s1.equals(s3));
        System.out.println(s3.equals(s4));
    }
}

 

4.11帮助文档查看String常用方法【记忆】

方法名说明
public boolean equals(Object anObject)比较字符串的内容，严格区分大小写(用户名和密码)
public char charAt(int index)返回指定索引处的 char 值
public int length()返回此字符串的长度

5.StringBuilder类

5.1StringBuilder类概述【理解】

StringBuilder 是一个可变的字符串类，我们可以把它看成是一个容器，这里的可变指的是 StringBuilder 对象中的内容是可变的

5.2StringBuilder类和String类的区别【理解】

  • String类：内容是不可变的

  • StringBuilder类：内容是可变的

5.3StringBuilder类的构造方法【记忆】

  • 常用的构造方法

    方法名说明
    public StringBuilder()创建一个空白可变字符串对象，不含有任何内容
    public StringBuilder(String str)根据字符串的内容，来创建可变字符串对象

  • 示例代码

public class StringBuilderDemo01 {
    public static void main(String[] args) {
        //public StringBuilder()：创建一个空白可变字符串对象，不含有任何内容
        StringBuilder sb = new StringBuilder();
        System.out.println("sb:" + sb);
        System.out.println("sb.length():" + sb.length());

        //public StringBuilder(String str)：根据字符串的内容，来创建可变字符串对象
        StringBuilder sb2 = new StringBuilder("hello");
        System.out.println("sb2:" + sb2);
        System.out.println("sb2.length():" + sb2.length());
    }
}

5.4StringBuilder类添加和反转方法【记忆】

  • 添加和反转方法

    方法名说明
    public StringBuilder append(任意类型)添加数据，并返回对象本身
    public StringBuilder reverse()返回相反的字符序列

  • 示例代码

public class StringBuilderDemo01 {
    public static void main(String[] args) {
        //创建对象
        StringBuilder sb = new StringBuilder();

        //public StringBuilder append(任意类型)：添加数据，并返回对象本身
//        StringBuilder sb2 = sb.append("hello");
//
//        System.out.println("sb:" + sb);
//        System.out.println("sb2:" + sb2);
//        System.out.println(sb == sb2);

//        sb.append("hello");
//        sb.append("world");
//        sb.append("java");
//        sb.append(100);

        //链式编程
        sb.append("hello").append("world").append("java").append(100);

        System.out.println("sb:" + sb);

        //public StringBuilder reverse()：返回相反的字符序列
        sb.reverse();
        System.out.println("sb:" + sb);
    }
}

5.5StringBuilder和String相互转换【应用】

  • StringBuilder转换为String

    public String toString()：通过 toString() 就可以实现把 StringBuilder 转换为 String

  • String转换为StringBuilder

    public StringBuilder(String s)：通过构造方法就可以实现把 String 转换为 StringBuilder

  • 示例代码

public class StringBuilderDemo02 {
    public static void main(String[] args) {
        /*
        //StringBuilder 转换为 String
        StringBuilder sb = new StringBuilder();
        sb.append("hello");

        //String s = sb; //这个是错误的做法

        //public String toString()：通过 toString() 就可以实现把 StringBuilder 转换为 String
        String s = sb.toString();
        System.out.println(s);
        */

        //String 转换为 StringBuilder
        String s = "hello";

        //StringBuilder sb = s; //这个是错误的做法

        //public StringBuilder(String s)：通过构造方法就可以实现把 String 转换为 StringBuilder
        StringBuilder sb = new StringBuilder(s);

        System.out.println(sb);
    }
}

 

 

5.8帮助文档查看StringBuilder常用方法【记忆】

方法名说明
public StringBuilder append (任意类型)添加数据，并返回对象本身
public StringBuilder reverse()返回相反的字符序列
public int length()返回长度，实际存储值
public String toString()

通过toString()就可以实现把StringBuilder转换为String

1. 继承

1.1 继承的实现（掌握）

  • 继承的概念

    • 继承是面向对象三大特征之一，可以使得子类具有父类的属性和方法，还可以在子类中重新定义，以及追加属性和方法

  • 实现继承的格式

    • 继承通过extends实现

    • 格式：class 子类 extends 父类 { }

      • 举例：class Dog extends Animal { }

  • 继承带来的好处

    • 继承可以让类与类之间产生关系，子父类关系，产生子父类后，子类则可以使用父类中非私有的成员。

  • 示例代码

    public class Fu {
    public void show() {
        System.out.println("show方法被调用");
    }
}
public class Zi extends Fu {
    public void method() {
        System.out.println("method方法被调用");
    }
}
public class Demo {
    public static void main(String[] args) {
        //创建对象，调用方法
        Fu f = new Fu();
        f.show();
​
        Zi z = new Zi();
        z.method();
        z.show();
    }
}

1.2 继承的好处和弊端（理解）

  • 继承好处

    • 提高了代码的复用性(多个类相同的成员可以放到同一个类中)

    • 提高了代码的维护性(如果方法的代码需要修改，修改一处即可)

  • 继承弊端

    • 继承让类与类之间产生了关系，类的耦合性增强了，当父类发生变化时子类实现也不得不跟着变化，削弱了子类的独立性

  • 继承的应用场景：

    • 使用继承，需要考虑类与类之间是否存在is..a的关系，不能盲目使用继承

      • is..a的关系：谁是谁的一种，例如：老师和学生是人的一种，那人就是父类，学生和老师就是子类

2. 继承中的成员访问特点

2.1 继承中变量的访问特点（掌握）

在子类方法中访问一个变量，采用的是就近原则。

  1. 子类局部范围找

  2. 子类成员范围找

  3. 父类成员范围找

  4. 如果都没有就报错(不考虑父亲的父亲…)

  • 示例代码

    class Fu {
    int num = 10;
}
class Zi {
    int num = 20;
    public void show(){
        int num = 30;
        System.out.println(num);
    }
}
public class Demo1 {
    public static void main(String[] args) {
        Zi z = new Zi();
        z.show();   // 输出show方法中的局部变量30
    }
}

2.2 super（掌握）

  • this&super关键字：

    • this：代表本类对象的引用

    • super：代表父类存储空间的标识(可以理解为父类对象引用)

  • this和super的使用分别

    • 成员变量：

      • this.成员变量 - 访问本类成员变量

      • super.成员变量 - 访问父类成员变量

    • 成员方法：

      • this.成员方法 - 访问本类成员方法

      • super.成员方法 - 访问父类成员方法

  • 构造方法：

    • this(…) - 访问本类构造方法

    • super(…) - 访问父类构造方法

2.3 继承中构造方法的访问特点（理解）

注意：子类中所有的构造方法默认都会访问父类中无参的构造方法

子类会继承父类中的数据，可能还会使用父类的数据。所以，子类初始化之前，一定要先完成父类数据的初始化，原因在于，每一个子类构造方法的第一条语句默认都是：super()

问题：如果父类中没有无参构造方法，只有带参构造方法，该怎么办呢？

1. 通过使用super关键字去显示的调用父类的带参构造方法
2. 在父类中自己提供一个无参构造方法

推荐方案：

自己给出无参构造方法

2.4 继承中成员方法的访问特点（掌握）

通过子类对象访问一个方法

  1. 子类成员范围找

  2. 父类成员范围找

  3. 如果都没有就报错(不考虑父亲的父亲…)

2.5 super内存图（理解）

  • 对象在堆内存中，会单独存在一块super区域，用来存放父类的数据

2.6 方法重写（掌握）

  • 1、方法重写概念

    • 子类出现了和父类中一模一样的方法声明（方法名一样，参数列表也必须一样）

  • 2、方法重写的应用场景

    • 当子类需要父类的功能，而功能主体子类有自己特有内容时，可以重写父类中的方法，这样，即沿袭了父类的功能，又定义了子类特有的内容

  • 3、Override注解

    • 用来检测当前的方法，是否是重写的方法，起到【校验】的作用

2.7 方法重写的注意事项（掌握）

  • 方法重写的注意事项

  1. 私有方法不能被重写(父类私有成员子类是不能继承的)

  2. 子类方法访问权限不能更低(public > 默认 > 私有)

  • 示例代码

public class Fu {
    private void show() {
        System.out.println("Fu中show()方法被调用");
    }
​
    void method() {
        System.out.println("Fu中method()方法被调用");
    }
}
​
public class Zi extends Fu {
​
    /* 编译【出错】，子类不能重写父类私有的方法*/
    @Override
    private void show() {
        System.out.println("Zi中show()方法被调用");
    }
   
    /* 编译【出错】，子类重写父类方法的时候，访问权限需要大于等于父类 */
    @Override
    private void method() {
        System.out.println("Zi中method()方法被调用");
    }
​
    /* 编译【通过】，子类重写父类方法的时候，访问权限需要大于等于父类 */
    @Override
    public void method() {
        System.out.println("Zi中method()方法被调用");
    }
}

2.8. Java中继承的注意事项（掌握）

  • Java中继承的注意事项

    1. Java中类只支持单继承，不支持多继承

      • 错误范例：class A extends B, C { }

    2. Java中类支持多层继承

  • 多层继承示例代码：

    public class Granddad {
​
    public void drink() {
        System.out.println("爷爷爱喝酒");
    }
​
}
​
public class Father extends Granddad {
​
    public void smoke() {
        System.out.println("爸爸爱抽烟");
    }
​
}
​
public class Mother {
​
    public void dance() {
        System.out.println("妈妈爱跳舞");
    }
​
}
public class Son extends Father {
    // 此时，Son类中就同时拥有drink方法以及smoke方法
}

 

4. 修饰符

4.1 package（了解）

  • 1、包的概念

    • 包就是文件夹，用来管理类文件的

  • 2、包的定义格式

    • package 包名; (多级包用.分开)

    • 例如：package com.heima.demo;

  • 3、带包编译&带包运行

    • 带包编译：javac –d . 类名.java

      • 例如：javac -d . com.heima.demo.HelloWorld.java

    • 带包运行：java 包名+类名

      • 例如：java com.heima.demo.HelloWorld

4.2 import（理解）

  • 导包的意义

    使用不同包下的类时，使用的时候要写类的全路径，写起来太麻烦了

    为了简化带包的操作，Java就提供了导包的功能

  • 导包的格式

    格式：import 包名;

    范例：import java.util.Scanner;

  • 示例代码（没有使用导包，创建的Scanner对

4.3 权限修饰符（理解）

4.4 final（应用）

  • fianl关键字的作用

    • final代表最终的意思，可以修饰成员方法，成员变量，类

  • final修饰类、方法、变量的效果

    • fianl修饰类：该类不能被继承（不能有子类，但是可以有父类）

    • final修饰方法：该方法不能被重写

    • final修饰变量：表明该变量是一个常量，不能再次赋值

4.5 final修饰局部变量（理解）

  • fianl修饰基本数据类型变量

    • final 修饰指的是基本类型的数据值不能发生改变

  • final修饰引用数据类型变量

    • final 修饰指的是引用类型的地址值不能发生改变，但是地址里面的内容是可以发生改变的

    • 举例：

      public static void main(String[] args){
    final Student s = new Student(23);
  	s = new Student(24);  // 错误
 	s.setAge(24);  // 正确
}

4.6 static（应用）

  • static的概念

    • static关键字是静态的意思，可以修饰【成员方法】，【成员变量】

  • static修饰的特点

    1. 被类的所有对象共享，这也是我们判断是否使用静态关键字的条件

    2. 可以通过类名调用当然，也可以通过对象名调用【推荐使用类名调用】

  • 示例代码：

class Student {

    public String name; //姓名
    public int age; //年龄
    public static String university; //学校	共享数据！所以设计为静态！

    public void show() {
        System.out.println(name + "," + age + "," + university);
    }

}

public class StaticDemo {
    public static void main(String[] args) {
	    // 为对象的共享数据赋值
        Student.university = "传智大学";

        Student s1 = new Student();
        s1.name = "林青霞";
        s1.age = 30;
        s1.show();

        Student s2 = new Student();
        s2.name = "风清扬";
        s2.age = 33;
        s2.show();
    }
}

4.7 static访问特点（掌握）

  • static的访问特点

    • 非静态的成员方法

      • 能访问静态的成员变量

      • 能访问非静态的成员变量

      • 能访问静态的成员方法

      • 能访问非静态的成员方法

    • 静态的成员方法

      • 能访问静态的成员变量

      • 能访问静态的成员方法

    • 总结成一句话就是：

      • 静态成员方法只能访问静态成员

 

 

1.多态

1.1多态的概述（记忆）

  • 什么是多态

    同一个对象，在不同时刻表现出来的不同形态

  • 多态的前提

    • 要有继承或实现关系

    • 要有方法的重写

    • 要有父类引用指向子类对象

1.2多态中的成员访问特点（记忆）

  • 成员访问特点

    • 成员变量

      编译看父类，运行看父类

    • 成员方法

      编译看父类，运行看子类

  • 代码演示

    • 动物类

public class Animal {
    public int age = 40;
​
    public void eat() {
        System.out.println("动物吃东西");
    }
}

猫类

public class Cat extends Animal {
    public int age = 20;
    public int weight = 10;
​
    @Override
    public void eat() {
        System.out.println("猫吃鱼");
    }
​
    public void playGame() {
        System.out.println("猫捉迷藏");
    }
}

测试类

public class AnimalDemo {
    public static void main(String[] args) {
        //有父类引用指向子类对象
        Animal a = new Cat();
​
        System.out.println(a.age);
//        System.out.println(a.weight);
​
        a.eat();
//        a.playGame();
    }
}

1.3多态的好处和弊端（记忆）

  • 好处

    提高程序的扩展性。定义方法时候，使用父类型作为参数，在使用的时候，使用具体的子类型参与操作

  • 弊端

    不能使用子类的特有成员

1.4多态中的转型（应用）

  • 向上转型

    父类引用指向子类对象就是向上转型

  • 向下转型

    格式：子类型 对象名 = (子类型)父类引用;

  • 代码演示

    •     动物类

public class Animal {
    public void eat() {
        System.out.println("动物吃东西");
    }
}

    猫类

public class Cat extends Animal {
    @Override
    public void eat() {
        System.out.println("猫吃鱼");
    }
​
    public void playGame() {
        System.out.println("猫捉迷藏");
    }
}

    测试类

public class AnimalDemo {
    public static void main(String[] args) {
        //多态
        //向上转型
        Animal a = new Cat();
        a.eat();
//      a.playGame();
​
​
        //向下转型
        Cat c = (Cat)a;
        c.eat();
        c.playGame();
    }
}

1.5多态的案例（应用）

  • 案例需求

    请采用多态的思想实现猫和狗的案例，并在测试类中进行测试

  • 代码实现

    • 动物类

    public class Animal {
    private String name;
    private int age;
​
    public Animal() {
    }
​
    public Animal(String name, int age) {
        this.name = name;
        this.age = age;
    }
​
    public String getName() {
        return name;
    }
​
    public void setName(String name) {
        this.name = name;
    }
​
    public int getAge() {
        return age;
    }
​
    public void setAge(int age) {
        this.age = age;
    }
​
    public void eat() {
        System.out.println("动物吃东西");
    }
}

    猫类

public class Cat extends Animal {
​
    public Cat() {
    }
​
    public Cat(String name, int age) {
        super(name, age);
    }
​
    @Override
    public void eat() {
        System.out.println("猫吃鱼");
    }
}

    狗类

public class Dog extends Animal {

    public Dog() {
    }

    public Dog(String name, int age) {
        super(name, age);
    }

    @Override
    public void eat() {
        System.out.println("狗吃骨头");
    }
}

    测试类

public class AnimalDemo {
    public static void main(String[] args) {
        //创建猫类对象进行测试
        Animal a = new Cat();
        a.setName("加菲");
        a.setAge(5);
        System.out.println(a.getName() + "," + a.getAge());
        a.eat();

        a = new Cat("加菲", 5);
        System.out.println(a.getName() + "," + a.getAge());
        a.eat();
    }
}

     

java封装继承多态实验总结_java封装继承多态理解3000字论文
weixin_36302331的博客
03-09 1323
一、怎么理解JAVA中封装、继承、多态他是一个“司机”，他的平时行为还有“开车”，我们再次划分出了“哺乳动物”这个类，一个类只能继承另一个类(或抽象类)但可以实现多个接口。打个比方封装，“鱼”等等)，接着，最后有“马”。 多态，正如上面朋友所说一重写，二重载。用汉字来打个比方，很显然，比如“开”这个字，在不同的时候各有的意思，比如“开门”、继承、多态 继承，先说说我对类的理解，类起到的作用有：分类...
Java封装继承多态练习题
qq_44918461的博客
08-09 3444
题目描述 某公司的雇员分为以下若干类： Employee：这是所有员工总的父类， 属性：员工的姓名，员工的生日月份。 方法：getSalary(intmonth) 根据参数月份来确定工资，如果该月员工过生日，则公司会额外奖励100 元。 SalariedEmployee：Employee 的子类，拿固定工资的员工。 属性：月薪 HourlyEmployee： Employee 的子类， 按小时拿工资的员工，每月工作超出160 小时的部分按照1.5 倍工资发放。 属性：每小时的工资、每月工作的小时数 Sale
Java学习笔记2021.1
Dadaist_的博客
01-06 239
编译好的Java程序是在JVM（java虚拟机上运行的。）JVM中有一个java解释器 这就是java跨平台的基础。 JDK与JRE的区别： JRE顾名思义是java运行时环境，包含了java虚拟机，java基础类库。是使用java语言编写的程序运行所需要的软件环境，是提供给想运行java程序的用户使用的。 JDK顾名思义是java开发工具包，是程序员使用java语言编写java程序所需的开发工具包，是提供给程序员使用的。JDK包含了JRE，同时还包含了编译java源码的编译器javac，还包含了很多jav
Java中的private关键字
aibai666的博客
02-02 7597
private关键字用于类中，作用是保护类中的成员变量或者成员方法的数据安全。凡是被private修饰过后的成员变量或成员方法都不能直接被外界调用。需要先在类中进行数值的修饰才可以被外界调用. private的使用 private 数据类型 变量名; 例: private int age;//表示变量名为age的成员变量已经被private进行修饰了 外界无法直接访问，除非在类中对age这个变量执行数值的修饰 针对private修饰后的变量的获取和修饰，被private修饰后的变量在类中也不能够
Java 基础 private
毛毛虫会长大
03-03 184
package cn.itcast.demo3; /* * 问题描述：定义Person的年龄，无法阻止不合理的数值设置进来。 * 解决方案：用private关键字将需要保护的成员变量进行修饰 * 一旦使用private进行修饰，那么本类当中仍然可以随意访问。 * 但是超出了本类范围之外就不能再直接访问了 * 简介访问private成员变量，就是定义一对setter/getter方法 * 必须...
public void setName(String name)
u012402926的专栏
07-11 6769
public void setName(String name) { 　　this.name = name; 　　} 　　public int getAge() { 　　return age; 　　} 　　public void setAge(int age) { 　　this.age = age; 　　} 　　public void cry(){ 　　System.out.p
java private_java private关键字用法实例
weixin_32101685的博客
02-12 415
这篇文章主要介绍了java private关键字用法实例,文中通过示例代码介绍的非常详细，对大家的学习或者工作具有一定的参考学习价值,需要的朋友可以参考下package java04;/** 问题描述：定义Person的年龄时，无法阻止不合理的数值设置进来* 解决方案：用private关键字将需要保护的成员变量进行修饰** 一旦使用了private进行修饰，那么本来类当中仍然可以随意访问。* 但是...
详解java封装继承多态
08-26
Java 封装继承多态详解 Java 中的封装、继承和多态是面向对象编程（Object Oriented Programming）三大特性。下面，我们将详细介绍这三者之间的关系和应用。 封装是指将数据和方法放入类中，并控制对数据的访问...
封装继承多态总结
12-06
封装继承多态总结
c++ 的封装继承多态例子
04-01
在C++编程语言中，封装、继承和多态是面向对象编程（OOP）的三大核心概念。下面将深入解析这三个关键概念，并结合"cppgood"这个可能包含示例代码的压缩包，来阐述它们在实际编程中的应用。 **封装** 是面向对象编程...
java对象中构造方法的作用
weixin_48009833的博客
06-29 395
实例化对象过程中会调用构造方法。如果没有写构造方法，实例化过程中系统默认会生成一个无参数无内容的构造方法来调用。但是如果写了一个带参数的构造方法，那系统就不会自动生成空参构造方法了，会导致我们无法调用 Student student = new Student()方法，所以我们还要同时写一个无参数无内容的构造函数。下面我们定义一个Student对象： public class Student{ private String name; private String subject;
Java泛型详解
拈花的专栏
08-24 409
什么是泛型程序设计 泛型程序设计是指编写的代码可以被很多不同类型的对象重用。比如，不需要给存储String的集合和存储File的集合分别设计不同的类。 类型参数的好处 在没有泛型类型之前，Java泛型程序设计是利用继承实现的。比如一个ArrayList，它内部维护一个Object数组，get出来的也是Object类型的对象，add进去的也是Object类型的对象，这样会导致get值出来的时候...
面向对象中的一些思考-类的构造方法是否能调用其成员方法
weixin_42101177的博客
02-18 933
python面对对象过程中遇到的一个问题 问题是类的构造方法是否能调用其成员方法？ 百度后，找到了这样一张图片，代码为java的，很中我们可以很明确体会到这个问题。 解释 类的构造方法是可以调用其成员方法的。 左图第一个方法是构造方法,而show方法是成员方法,构造方法中是可以使用成员方法的 子类拥有父类的所有成员变量和成员方法,因此子类中使用父类的成员变量应该用this引用,而不是super,...
SpringBoot
weixin_46042631的博客
09-20 742
主启动类只会扫描同包及其子包。可以设置这个字段来指定扫描的基准包。 SpringBoot的自动配置功能，都在spring-boot-autoconfigure中 <dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-autoconfigure</artifactId> <version>2.
java set 包含_关于Java的Set的集合是否包括问题，如下为什么不包括？
weixin_39631572的博客
02-13 165
packagecom.owant.test;importjava.util.HashSet;importjava.util.Set;publicclassSetTest{publicstaticvoidmain(String[]str){//集合Setset=newHashSet();Pointp1=new...package com.owant.test;import java.util.Has...
java中set和get方法的理解，写给初学者
对半切开的奇异果
02-21 1万+
对于JAVA初学者来说，set和get这两个方法似乎已经很熟悉了，这两个方法是JAVA变成中的基本用法，也是出现频率相当高的两个方法。 为了让JAVA初学者能更好的理解这两个方法的使用和意义，今天笔者来谈一下自己对这两个方法的理解，如果你对于这两个方法还有困惑甚至完全不知道这两个方法是做什么的，那你看下面这篇文章很有用。如果你对于set和get这两个方法已经很熟悉了，那么你完全不用看这篇文章
public void与public static void区别
热门推荐
qq_41867256的博客
02-26 1万+
public void定义的是普通的方法，而public static void 定义的是静态的方法。 普通的方法需要new对象去调用，而静态的方法可以直接用类名去调用。
封装 继承 多态
最新发布
07-27
封装、继承和多态是面向对象编程中的三个重要概念。 封装是指将数据和对数据的操作封装在一个类中，通过访问修饰符来控制对数据的访问权限。这样可以隐藏内部实现细节，提高代码的安全性和可维护性。\[2\] 继承是指一个类可以继承另一个类的属性和方法。通过继承，子类可以重用父类的代码，并且可以在子类中添加新的属性和方法。这样可以提高代码的复用性和可扩展性。\[2\] 多态是指同一个方法在不同的对象上可以有不同的行为。通过多态，可以实现方法的重写和重载，使得程序可以根据对象的实际类型来调用相应的方法。这样可以提高代码的灵活性和可扩展性。\[1\] 总结起来，封装、继承和多态是面向对象编程的三个基本特性，它们可以使代码更加模块化、可维护和可扩展。 #### 引用[.reference_title] - *1* *2* [封装、继承、多态](https://blog.csdn.net/yahid/article/details/125665027)[target="_blank" data-report-click={"spm":"1018.2226.3001.9630","extra":{"utm_source":"vip_chatgpt_common_search_pc_result","utm_medium":"distribute.pc_search_result.none-task-cask-2~all~insert_cask~default-1-null.142^v91^insertT0,239^v3^insert_chatgpt"}} ] [.reference_item] - *3* [C++ 类的封装继承多态](https://blog.csdn.net/secondtonone1/article/details/124485035)[target="_blank" data-report-click={"spm":"1018.2226.3001.9630","extra":{"utm_source":"vip_chatgpt_common_search_pc_result","utm_medium":"distribute.pc_search_result.none-task-cask-2~all~insert_cask~default-1-null.142^v91^insertT0,239^v3^insert_chatgpt"}} ] [.reference_item] [ .reference_list ]
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值