JavaSE语法（6）——详细解读Java中的类与访问修饰符

已于 2023-01-16 21:57:38 修改
阅读量1.2k 收藏 4
点赞数 13
分类专栏： JavaSE 文章标签： java
于 2022-11-13 18:52:06 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/che__dan/article/details/127669373
版权

目录

✏️类定义和使用

1.类的定义格式

2.类的实例化

3.类的内存模型

✏️this引用

1. 引入

2.什么是this引用

✏️构造方法

1.概念及用法

2.this引用在构造方法中的应用

✏️封装

1.访问限定符

2.private

3.包

3.1 概念

3.2 导入包中的类：import

4. 什么都不写的时候的默认权限（default）

✏️类定义和使用

        类是Java程序的基本要素，一个Java应用程序就是由若干类所构成的。类声明的变量被称作对象变量，简称对象（就有点类似于C语言中的结构体）。

1.类的定义格式

        格式：

// 创建类
class ClassName{
    //field; 字段(属性) 或者 成员变量
    //method; 行为 或者 成员方法
}

        class为定义类的关键字，ClassName为类的名字，{}中为类的主体。

        类中包含的内容称为类的成员。属性主要是用来描述类的，称之为类的成员属性或者类成员变量。方法主要说明类具有哪些功能，称为类的成员方法。

例：

class Cat{
    public String name;
    public String color;

    //猫的叫声
    public void meow() {
        System.out.println(name + ":喵喵喵~");
    }

    //行为
    public void behavior() {
        System.out.println(name + ":舔爪子");
    }
}
 

问题：为什么在方法中能直接用 name 变量呢？

答：name是定义在方法外面的，就类似于C语言中的全局变量，整个类里的方法都可以直接用该变量。（特殊的情况除外，如加了static的方法 等，static关键字的详细介绍后面会更新）。

需要注意的：

//可以在声明的同时指定变量的初值
class A{
    int a = 12;
    float b = 12.33f;
}

//以下是错误的用法
class A{
    int a;
    float b;
    a = 12;           //非法
    b = 12.33f;       //非法
}

注意：

  • 在声明成员变量时如果没有指定初始值，Java编译器会为其指定相应的默认值。
  • 类名注意采用大驼峰定义（首字母大写）
  • 一般一个文件当中只定义一个类。
  • main方法所在的类一般要使用public修饰(注意：Eclipse默认会在public修饰的类中找main方法)。
  • public修饰的类必须要和文件名相同。
  • 成员前写法暂时统一为public，方法暂时不带 static 关键字。（关于static的详细介绍会在后续更新）

2.类的实例化

        类是用户自定义了一个新的类型，比如上述的：Cat类；用 类 类型创建对象的过程，称为类的实例化。

  • 对象的声明
类的名字 对象的名称;

例：

Cat c;
  • 为声明的对象分配变量

        使用new运算符来创建对象；

public class Main{
    public static void main(String[] args) {
        Cat c = new Cat();
        c.name = "小白";
        c.color = "白色";
        c.behavior();
        c.meow();

        Cat c2 = new Cat();
        c2.name = "小黑";
        c2.color = "黑色";
        c2.behavior();
        c2.meow();
    }
}

 运行结果：

小白:舔爪子
小白:喵喵喵~
小黑:舔爪子
小黑:喵喵喵~

注意：

  • new 关键字用于创建一个对象的实例。
  • 使用“ . ”来访问对象中的属性和方法。
  • 同一个类 类型可以创建多个实例。

3.类的内存模型

        类的信息放在了方法区、对象的引用存放在栈中，对象的实例存放在堆中。

JavaSE语法（5）——【数组(基本类型变量与引用类型变量的区别、二维数组、二维数组打印、jvm的内存分布……)】_虾料的博客-CSDN博客https://blog.csdn.net/Che__dan/article/details/127608985?spm=1001.2014.3001.5501关于方法区、栈、堆 ，上面文章有介绍👆。

有如下代码：

public class Main{
    public static void main(String[] args) {
        Cat c = new Cat();
        c.name = "小白";
        c.color = "白色";
        c.meow();
    }
}

class Cat{
    public String name;
    public String color;

    //猫的叫声
    public void meow() {
        System.out.println(name + ":喵喵喵~");
    }
}
  • 当程序开始时，Main类里的信息（成员变量、成员方法）会存到方法区。

4a4803144186497dabcfdc873db49db0.jpeg

  •  当开始执行main方法时，栈里就会开辟一个空间来装main方法（入栈）。

538c944cd1b247b78b013002d10e265c.jpeg

  •  当执行到 Cat c = new Cat() 时，方法区就会加载Cat类的信息，同时在堆中创建Cat的实例，栈里的 c ，存储了堆里的Cat实例的地址；堆里的Cat实例中的方法存储了方法区里的方法的地址。

8857b88fd35d4dbab8b4de6260df1e85.jpeg

  •  对成员变量进行赋值后(对字符串赋值涉及到常量池，常量池详细内容后面更新)，执行到c.meow()时，通过地址获取到方法区里的meow方法的信息，然后在栈里开辟一个空间。

55735e257e274c07b8e266668230bf33.jpeg

✏️this引用

1. 引入

class Student{
    public int age;
    public int height;

    public void set(int a, int h){
        age = a;
        height = h;
    }
    public void print(){
        System.out.println("age: " +age +  " height: " + height);
    }
}

public class Main{
    public static void main(String[] args) {

        Student s1 = new Student();
        Student s2 = new Student();
        //输入年龄、身高
        s1.set(18,180);
        s2.set(20,184);
        //打印
        s1.print();
        s2.print();
    }
}

结果：

age: 18 height: 180
age: 20 height: 184

        输出没问题，但是我们把set()里的参数改一下：

class Student{
    public int age;
    public int height;
    
    //改成 age height
    public void set(int age, int height ){
        age = age;
        height = height;
    }
    public void print(){
        System.out.println("age: " +age +  " height: " + height);
    }
}

public class Main{
    public static void main(String[] args) {

        Student s1 = new Student();
        Student s2 = new Student();
        //输入年龄、身高
        s1.set(18,180);
        s2.set(20,184);
        //打印
        s1.print();
        s2.print();
    }
}

        这时Student里的成员变量的值是什么？

结果：

age: 0 height: 0
age: 0 height: 0

        发现age与height的值并没有改变，是因为set的形参与成员变量名相同了，这时set方法里的age与height不算Student的成员变量，而是算作形参了，要避免这一现象，就可以用this关键字。

2.什么是this引用

        this表示某个对象，this引用指向当前对象(成员方法运行时调用该成员方法的对象)，在成员方法中所有成员变量的操作，都是通过该引用去访问。

        以上面的例子：

class Student{
    public int age;
    public int height;
    
    //改成 age height
    //加了this
    public void set(int age, int height ){
        this.age = age;
        this.height = height;
    }
    public void print(){
        System.out.println("age: " +this.age +  " height: " + this.height);
    }
}

public class Main{
    public static void main(String[] args) {

        Student s1 = new Student();
        Student s2 = new Student();
        //输入年龄、身高
        s1.set(18,180);
        s2.set(20,184);
        //打印
        s1.print();
        s2.print();
    }
}

结果：

age: 18 height: 180
age: 20 height: 184

注意：

  • this的类型：对应类类型引用，即，哪个对象调用就是哪个对象的引用类型。
  • this只能在"成员方法"中使用（加了static的方法不行，后续更新）。
  • 在"成员方法"中，this只能引用当前对象，不能再引用其他对象。
  • this也可以调用该类的方法，就跟调用变量一样。

  • this是“成员方法”第一个隐藏的参数，编译器会自动传递，在成员方法执行时，编译器会负责将调用成员方法对象的引用传递给该成员方法，this负责来接收。

        例：在set方法的形参列表里加一个“Student this”。

58fb1b175eae4990a7246ee50d38f4c4.png

 结果：

91d5a8b555a54d2b875062bda27a1eab.png

         能编译过，说明this就是本类的引用。

✏️构造方法

1.概念及用法

        构造方法(也称为构造器)是一个特殊的成员方法，名字必须与类名相同，在创建对象时，由编译器自动调用，并且在整个对象的生命周期内只调用一次，构造方法的作用就是对对象中的成员进行初始化。

class Student{
    public int age;
    public int height;

    // 构造方法：
    // 名字与类名相同，没有返回值类型，设置为void也不行
    // 一般情况下使用public修饰
    // 在创建对象时由编译器自动调用，并且在对象的生命周期内只调用一次
    public Student(int age,int height) {
        System.out.println("构造方法被调用了！！！");
        this.age = age;
        this.height = height;
    }
    public void print(){
        System.out.println("age: " +age +  " height: " + height);
    }
}

public class Main{
    public static void main(String[] args) {
        //输入初始值
        Student s1 = new Student(18,182);

        s1.print();
    }
}

结果：

构造方法被调用了！！！
age: 18 height: 182

注意：

  • 构造方法的参数有几个，new的时候就要输入几个参数，否则会报错。

9d7ec0d14648490d97043eabead6bebb.png

  • 当没有写构造方法的时候，编译器会自动生成一个无参数的构造方法（并且不会显示），如果写了就不会生成，这也是为什么上一条会报错的原因。

  • 构造方法可以重载！当我们既想在new的时候不输入参数不报错，又想输入参数，那么就可以重载构造方法。
class Student{
    public int age;
    public int height;

    // 构造方法：
    // 名字与类名相同，没有返回值类型，设置为void也不行
    // 一般情况下使用public修饰
    // 在创建对象时由编译器自动调用，并且在对象的生命周期内只调用一次
    public Student() {
        System.out.println("无参的构造方法被调用了！！！");
        //也可以在这里对age 和 height 赋值
    }

    public Student(int age,int height) {
        System.out.println("有参的构造方法被调用了！！！");
        this.age = age;
        this.height = height;
    }
    public void print(){
        System.out.println("age: " +this.age +  " height: " + this.height);
    }
}

public class Main{
    public static void main(String[] args) {
        Student s1 = new Student();
        s1.print();

        Student s2 = new Student(18,180);
        s2.print();
    }
}

结果：

无参的构造方法被调用了！！！
age: 0 height: 0
有参的构造方法被调用了！！！
age: 18 height: 180

2.this引用在构造方法中的应用

        this可以调用其他构造方法，格式：" this() "，因为this就是Student的引用，可以把this看作Student。
 

class Student{
    public int age;
    public int height;
    
    public Student() {
        this(12,181);
    }

    public Student(int age,int height) {
        System.out.println("有参的构造方法被this调用了！！！");
        this.age = age;
        this.height = height;
    }
    public void print(){
        System.out.println("age: " +this.age +  " height: " + this.height);
    }
}

public class Main{
    public static void main(String[] args) {
        Student s1 = new Student();
        s1.print();
    }
}

结果：

有参的构造方法被this调用了！！！
age: 12 height: 181

注意：

  • this(...)必须是构造方法中第一条语句，不然会报错。

dc8464c36d0d41e58826dde61e8729e6.png

  •  不能形成环。

ea5661155ad84fc29e043e48d087287d.png

✏️封装

1.访问限定符

        在前面我们都是用public来修饰方法、变量、类，这有什么玄机呢？

        Java中主要通过类和访问权限来实现封装：类可以将数据以及封装数据的方法结合在一起，而访问权限用来控制方法或者字段能否直接在类外使用。Java中提供了四种访问限定符：

983123e8529f4a3681ca62a8e5bf3595.jpeg

  • public：可以理解为一个人的外貌特征，谁都可以看得到。
  • default（什么都不写的时候的默认权限）：对于自己家族中(同一个包中)不是什么秘密，对于其他人来说就是隐私了。
  • private：只有自己知道，其他人都不知道。

 注意：

  • protected主要是用在继承中。（更新继承的时候再来详细介绍，本篇就不介绍了）
  • default 权限指：什么都不写时的默认权限！！！
  • 访问权限除了可以限定类中成员（包括方法）的可见性，也可以控制类的可见性。

2.private

        看下面代码：

class Student {
    private int age;
    private int height;
    
    public void print() {
        System.out.println("age: " + this.age + " height: " + this.height);
    }
}


public class Main{
    public static void main(String[] args) {
        Student s1 = new Student();
        s1.age = 18;
        s1.height = 184;
    }
}

结果：

79798e29137448b8a3c64e091a2affd6.png

         可以看到报错了，是因为private只能在同一个类中才能被访问到，那么有什么方法可以改变age 和 height 呢？

        我们可以用public修饰的方法来修改其值，这其实体现着封装的思想。

class Student {
    private int age;
    private int height;

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

    public int getHeight() {
        return height;
    }

    public void setHeight(int height) {
        this.height = height;
    }

    public void print() {
        System.out.println("age: " + this.age + " height: " + this.height);
    }
}


public class Main{
    public static void main(String[] args) {
        Student s1 = new Student();
        s1.setAge(18);
        int age = s1.getAge();
        System.out.println(age);

        s1.setHeight(180);
        int height = s1.getHeight();
        System.out.println(height);

        s1.print();
    }
}

结果：

18
180
age: 18 height: 180

        我们可以用setAge()、setHeight()来赋值，getAge()、getHight()来取值。

3.包

3.1 概念

        为了更好的管理类，把多个类收集在一起成为一组，称为软件包。

        包是Java语言有效地管理类的一个机制。在不同Java源文件中可能出现名字相同的类，如果用户想区分这些类，就需要使用包名。使用包名可以有效地区分名字相同的类，当不同Java源文件中的两个类的名字相同时，它们可以通过隶属于不同的包来相互区分。

3.2 导入包中的类：import

        Java 中已经提供了很多现成的类供我们使用。例如Date类：可以使用 java.util.Date 导入 java.util 这个包中的 Date类。

public class Main{
    public static void main(String[] args) {
        java.util.Date date = new java.util.Date();
        // 得到一个毫秒级别的时间戳
        System.out.println(date.getTime());
    }
}

        但是这样操作太复杂了，我们直接用import来导入包：

import java.util.Date;

public class Main{
    public static void main(String[] args) {
        Date date = new java.util.Date();
        // 得到一个毫秒级别的时间戳
        System.out.println(date.getTime());
    }
}

        如果我们还想使用 util 里其它的类，比如：Arrays类。这时可以用“ * ”：

import java.util.*;
public class Main{
    public static void main(String[] args) {
        Date date = new java.util.Date();
        // 得到一个毫秒级别的时间戳
        System.out.println(date.getTime());
        
        int[] arr = {5,4,3,2,1};
        Arrays.sort(arr);
    }
}
  • 注意：这样使用也有风险！！！
import java.util.*;
import java.sql.*;
public class Main{
    public static void main(String[] args) {
        Date date = new java.util.Date();
        // 得到一个毫秒级别的时间戳
        System.out.println(date.getTime());
    }
}

结果：

e9963d8694b143f6892cb37eb7773bb0.png

         在util 和 sql 中都有Data这个类，这时会冲突，这就需要写详细一点了。

4. 什么都不写的时候的默认权限（default）

        创建了两个包、并在里面写了不同的类：

9267631d0a17405fb2201ecaca741e3e.png

demo2包：

package demo2;

public class Student {
    
    //什么修饰符都没写
    int age;
    int height;

    public void print() {
        System.out.println("age: " + this.age + " height: " + this.height);
    }
}

 demo1包：

package demo1;

//导包中的类
import demo2.Student;

public class Main{
    public static void main(String[] args) {
        Student s1 = new Student();
        s1.age = 18;
        s1.height = 180;
        s1.print();
    }
}

结果：

2c00dad1e34c469fa40a283131db4e5c.png

同一个包 demo1：

6feadd42434947209b73950d8a6bf89d.png

 结果（代码一样）：

age: 18 height: 180

修饰类的情况：

c024411dbec5499fbbb909534d4591bd.png

demo2：

package demo2;

//该类没有写修饰符，即为默认的权限
class Student {
    int age;
    int height;

    public void print() {
        System.out.println("age: " + this.age + " height: " + this.height);
    }
}

 demo1：

package demo1;

import demo2.Student;

public class Main{
    public static void main(String[] args) {
        Student s1 = new Student();
        s1.age = 18;
        s1.height = 180;
        s1.print();
    }
}

结果：

6e24deea1b2c4e52983acf623686839c.png

总结：什么都不写的时候的默认权限（default），只有在同一个包中才能被访问到。不只是变量，修饰符加在方法、类上都是一样的，而public权限在什么地方都能被访问，就不介绍了。

关于Java中各种修饰符与访问修饰符的说明
liaojx的专栏
12-08 1571
 关于Java中各种修饰符与访问修饰符的说明类：访问修饰符  修饰符  class 类名称 extends 父类名称 implement 接口名称（访问修饰符与修饰符的位置可以互换）访问修饰符名称说明备注public可以被所有类访问（使用）public类必须定义在和类名相同的同名文件中packa
java 类的访问修饰符_Java类访问修饰符
weixin_39550940的博客
02-12 192
对于Java类的访问修饰符有public, 包级私有两种。在项目pro下包和类的组织如下：//pro//mypack1//Student.java//Test.java//mypack2//Test.javapackage mypack1;class Student {private int stuId;private String stuName;public Student(String st...
java访问控制修饰符
qq_74722140的博客
04-03 279
protected(保护):被protected修饰的成员变量和成员方法可以在声明它们的类中访问,在该类中的子类访问,也可以在与该类同一个包中的类访问,但不能在位于其他包的非子类访问。缺省:指不使用访问修饰符。不使用访问修饰符的变量和方法可以在声明它们的类中访问,也可以在与该类同一个包中的类中访问,但不能在位于其他包中的类访问。private(私有):只能在声明它们的类中访问,而不能在其他类包括其子类中访问。public(共有):被public修饰的成员变量和成员方法可以在所以类中访问。
java类访问修饰符_java中的方法，类，访问修饰符
weixin_34831191的博客
02-12 150
1.方法的定义定义方法的五个要素：修饰词，返回值类型，方法名，参数列表，方法体public static void main(String[] args){System.out.println("方法体");}return语句可以将数据返回给方法的调用。return后面直接加分号，表示结束方法。2.方法的重载方法的签名：方法名和参数列表一个类中，不能有两个方法的签名完全相同，即一个类中不能有两个方...
java中的修饰符_Java中各种修饰符与访问修饰符
weixin_30980025的博客
02-21 172
Java中各种修饰符与访问修饰符类：访问修饰符修饰符class 类名称 extends 父类名称 implement 接口名称(访问修饰符与修饰符的位置可以互换)访问修饰符名称说明备注public可以被所有类访问(使用)public类必须定义在和类名相同的同名文件中package可以被同一个包中的类访问(使用)默认的访问权限，可以省略此关键字，可以定义在和public类的同一个文件中修饰符名称...
Linuxrgw#java#javase知识点 ----6 （访问权限修饰符）1
07-25
1、包： 1、全部小写 2、第一级 指该项目的类型，如com,org,gov等， 2、 访问权限修饰符 3、封装性： 1、静态属性： 1、static属性可以使
JAVASE基础语法的学习 Java学习资料
最新发布
06-25
封装是将数据和方法打包在一起的机制，通过访问修饰符（public、private、protected、默认）来控制数据的访问权限。 7. **继承与多态**： 继承允许一个类（子类）继承另一个类（父类）的属性和方法，提高了代码的...
javaSE基础语法，详细注释和标签，排版整齐
09-14
- `public`：访问修饰符，表示该类或方法可以被任何地方访问。 - `class`：定义类的关键词。 - `static`：用于声明静态变量或静态方法，它们属于类而非类的实例。 - `main`：程序的入口点，接收`String[]`类型的...
【JavaSE】访问修饰符
兮动人
10-26 229
1. 基本介绍 java 提供四种访问控制修饰符号，用于控制方法和属性(成员变量)的访问权限（范围）: 公开级别:用 public 修饰,对外公开 受保护级别:用 protected 修饰,对子类和同一个包中的类公开 默认级别:没有修饰符号,向同一个包的类公开. 私有级别:用 private 修饰,只有类本身可以访问,不对外公开. 2. 四种访问修饰符的访问范围 3. 使用的注意事项 修饰符可以用来修饰类中的属性，成员方法以及类 只有默认的和public才能修饰类，并且遵循上述访问权限的特点。
JavaSE static final及abstract修饰符实例解析
08-19
JavaSE 中的 static、final 及 abstract 修饰符都是非常重要的概念，它们在编程中扮演着不同的角色，下面我们将详细地介绍它们的用法和特点。 static 修饰符 static 修饰符可以修饰变量、方法和代码块。静态变量...
头歌Java实践作业-Java类和对象之访问限制
一个专注于客户端开发的技术er，不定期更新Android，Flutter，HormonyOS等方向的使用心得和感悟
10-12 3919
Java类和对象之访问限制 任务描述 相关知识 default public private protected 编程要求 测试说明 任务描述 本关任务：实现图书类，该类包含了图书的基本属性和信息。 相关知识 为了完成本关任务，你需要掌握：Java 访问控制修饰符的使用。 Java 中，可以使用访问控制符来保护对类、变量、方法和构造方法的访问。Java 支持 4 种不同的访问权限。 访问控制符是一组限定类、属性或方法是否可以被程序里的其他部分访问和调用的修饰符。类的访问控制符只能是空或者 pu
java 成员 类 包认识及成员类的访问限定符
自由理想的足迹
04-08 1599
main：一个项目中可有多个main方法但是，要选择进行编译所以，最好只写一个main方法。 package：一个项目可以有多个包，且包内也可以有包；并且包名可以和类名一样，但是包名的目录，而类名指定一个客观对象。 class：一个抽象类是可以继承一个具体类的。新建的一个页面只有一个类可以是public型的。 类和成员的权限限制符号：  类有 public 默认 abstract fina
面向对象的关键字以及包和访问限定修饰符以及面向对象的三大特性
langlangfxl的博客
10-28 299
一、static、this关键字 1、this关键字 this关键字表示的是当前对象，主要在方法中使用（普通，构造），主要作用是为了区分全局变量和局部变量 如果用一个对象调用带有this的方法，那么这个this就表示的是谁 this关键字，在方法中可以当作一个实际的对象进行使用 2、static关键字 2、1用static修饰属性 静态属性属于类所有，所有的实例化对象共享类的静态属性。一个对象对类的静态属性的修改会涌向到其他类的引用值 类是一个特殊的对象，静态方法只能调用静态方法，静态方法只能调用
java 限定符_浅析java构造函数前的访问限定符问题
weixin_35201342的博客
02-21 148
曾经一直有个问题困扰着我，我一直以为构造函数前面不能加任何东西，但偶然间看到了一本书上写的代码中，构造函数前加了public限定符，心里很是疑惑，构造函数前加毛访问限定符啊？？！ 在网上查了很多资料，论坛上发帖，依旧没有解决这个问题。今天亲自测试了下，得出了答案。首先，在两个源文件中建立两个类，HolidaySked和text；代码如下：文件 HolidaySked.java源码：import ...
Java 基础知识必知必会
晨曦蜗牛
02-02 253
Java 中的 final 关键字可以用于声明属性（常量），方法和类。当 final 修饰属性时，代表该属性一旦被分配内存空间就必须初始化，它的含义是“这是无法改变的”或者“终态的”。在变量前面添加关键字 final 即可声明一个常量。在 Java 编码规范中，要求常量名必须大写。 字符串连接有两种方法： 使用 +，比如 String s = "Hello " + “World!”。 使用 String 类的 concat() 方法。 在面向对象中有一个非常重要的知识点，就是构造方法。每个类..
JavaSE之访问修饰符
Bennett的博客
07-22 162
本篇文章主要介绍Java中的访问修饰符，介绍不同修饰符的访问权限范围。以及修饰属性、方法、类时的作用。
JavaSE基础:package,import,访问控制权限修饰符-28
11-10
JavaSE基础是学习Java编程语言的关键，其中包括了对核心概念的理解和掌握，如包(package)、导入(import)、访问控制权限修饰符等。这些概念在编写高质量、可维护的Java代码中起着至关重要的作用。 1、**多态基础语法...
第5章-子类与继承-上机实验1（猫与狗）
晴天下的大头娃娃
10-10 3544
实验目的： 由继承得到的类叫做子类，被继承的类称作父类，Java中子类只有一个父类 代码： Animal.java public class Aminal { protected String name; public void showName(){//这个方法自始至终没被重写 System.out.println("different
Java网课基础笔记（2）19-07-14
fenger_c的博客
07-14 432
1.extends：继承，子类继承父类非私有的属性 //父类 public class Animal{ public int foot; public int getFoot() { return foot; } public void setFoot(int foot) { this.foot = foot; } public void attck() { S...
Java基础班第九天（上）多态
weixin_40079205的博客
10-06 253
三个内容 ：多态、抽象类、接口  第一节：讲解这个多态的概念 class Demo1_Poly { public static void main(String[] args) { Animal c; c = new Cat(); c.eat(); } /* A:多态的概述 事物存在的多种形式 B:多态的前提 1：要有继承关系 2：要有方法重写 3...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值