Java-day07(面向对象-3,4)

继承

  1. 将多个类中共有的属性，方法剥离出来单独创建一个共有类，当需要使用共有的属性与方法时，就可以通过继承(extends)来调用共有的属性与方法。
  2. 通过"class A extends B" 来实现类的继承（子类：A 父类（或基类SuperClass）：B)
  3. 子类继承父类，父类中声明的属性，方法，子类就可以获取得到（父类中的私有方法，属性，子类可以获得，但由于封装性的设计，子类不可以直接调用）
  4. 子类除了通过继承父类的属性与方法，还可以自己定义特有的成分
  5. 在继承中，子类是父类功能的"扩展"，即子类不是父类的子集。
  6. Java类的继承只支持单继承（一个子类只能继承一个父类，一个父类可以有多个子类）
  7. 子类父类是相对的概念（子类可以用直接父类（1个），间接父类（0~多个））

事例

//这些类可以写在不同的文件里
public class Test3 {                                                  public static void main(String[] args) {Student s = new Student("学生",17);s.info();Worker w = new Worker("打工人",32);w.info();}
}class Student extends Person{    // private String name; // private int age; private String school = "明德完小"; public Student(String name,int age){ // this.name = name; // this.age = age; this.setAge(age); this.setName(name); }// public void setName(String name){ // 	this.name = name; // }// public void setAge(int age){ // 	this.age = age; // }// public String getName( ){ // 	return name; // }// public String getAame( ){ // 	return age; // }public String getSchool( ){ return school; }// public void info(){ // 	System.out.println("name: " + this.name + "age: " + this.age); // }}class Worker extends Person{//继承Person类// private String name;// private int age;public Worker(String name,int age){// this.name = name;// this.age = age;this.setAge(age);this.setName(name);}// public void setName(String name){// 	this.name = name;// }// public void setAge(int age){// 	this.age = age;// }// public String getName( ){// 	return name;// }// public String getAame( ){// 	return age;// }// public void info(){// 	System.out.println("name: " + this.name + "age: " + this.age);// }
}
class Person{//将上面相同的部分，合成一个类private String name;private int age;public void setName(String name){this.name = name;}public void setAge(int age){this.age = age;}public String getName( ){return name;}public String getAame( ){return age;}public void info(){System.out.println("name: " + this.name + "  " + "age: " + this.age);}}

练习
题一
在这里插入图片描述

// 父类
class ManKind{private int salary; private int sex;public  int getSex() {return sex;}public  int getSalary() {return salary;}		public  void setSex(int sex) {this.sex = sex;}	public void setSalary(int salary){this.salary = salary;}public void manOrWorman(){if(sex == 1){System.out.println("man");}if(sex == 0){System.out.println("woman");}}public void employeed(){if(salary == 0){System.out.println("no job");}if(sex != 0){System.out.println("job");}}
}
//子类class Kids extends ManKind{private int yearOld;public void yearOld(int yearOld){this.yearOld = yearOld;}public void printAge(){System.out.println("yearOld: " + yearOld);}
}public class Test3{public static void main(String[] args) {Kids somekid = new Kids();somekid.setSalary(0);somekid.setSex(0);somekid.yearOld(14);somekid.employeed();somekid.manOrWorman();somekid.printAge();}
}

题二
在这里插入图片描述

//这些类可以写在不同的文件里
public class Person{     private String name;private int age;private char sex;public void setName(String name){this.name = name;}public void setAge(int age){this.age = age;}public void setSex(char sex){this.sex = sex;}public String getName( ){return name;}public int getAge( ){return age;}public char getSex(){return sex;}public Person(String name,char sex,int age){this.age = age;this.name = name;this .sex = sex;}public String toString(){return 0;}}class Student extends Person{private long number;private int math;private int english;private int computer;public Student(String n,char s,int a,long k,int m,int e,int c){// this.setName(n);// this.setAge(a);// this.setSex(s);super(n, s, e);//调用父类的构造器this.number = k;this.computer = c;this.math = m;this.english = e;	}public double aver(){return 0;}public int max(){return 0;}public String toString(){return 0;}
}

重写

修饰符  返回值类型 方法名(参数列表){}

前提：有子类继承父类
对父类同名方法的重写（覆盖），即子类继承父类后，父类的方法不适合子类，则可以选择重写来对父类的方法进行覆盖。
注意区分重写与重载的区别

重写规则

  1. 子类的方法的"返回值 方法名（参数列表）" 与父类的方法一致
  2. 子类的方法的修饰符不能小于父类方法的修饰符
  3. 若父类方法抛异常，那么子类方法抛的异常类型不能大于父类的异常类型
  4. 子父类的方法必须同为static或非static的

事例

public class Person{                                      private String name;private int age;private char sex;public void setName(String name){this.name = name;}public void setAge(int age){this.age = age;}public void setSex(char sex){this.sex = sex;}public String getName( ){return name;}public int getAge( ){return age;}public char getSex(){return sex;}// public Person(String name,char sex,int age){// 	this.age = age;// 	this.name = name;// 	this .sex = sex;// }public void sleep(){System.out.println("我是人，我要要睡觉！");}
}class Student extends Person{ // public Student(String name, char sex, int age) {// 	super(name, sex, age);// 	//TODO Auto-generated constructor stub// }//对父类sleep()方法重写public void sleep(){System.out.println("我是学生，我要睡觉！");}}

多态

一个事务的多种表达形态

  1. 表现：
    方法的重载和重写。
    子类对象的多态性–直接应用在抽象类和接口上。
  2. Java引用变量有两个类型：编译时类型（”看左边“由声明该变量时使用的类型决定）和运行时类型（”看右边“由实际赋给该变量的对象决定）
  3. 虚拟方法调用：通过父类的引用指向子类的对象实体，调用方法时，实际执行的是子类重写父类的方法
  4. 子类对象的多态性使用的前提：
    有类的继承
    有子类对父类方法的重写
    子类对象的多态性并不适用于属性

instanceof

（判断某个对象是否属于莫类的实例）

格式：对象a instanceof 类A
判断对象a是否为类A的实例，是就返回true,不是就返回false;
如果对象a是类A的一个实例，那对象a一定是类A的父类的实例
事例

//父类
class Person{                  private int age;private String name;public Person(){super();}public Person(String name,int age){super();this.age = age;this.name =name;}public  int 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 ren(){System.out.println("我是人类");}
}
//子类
class Man extends Person{private boolean smoking;public Man(){super();}public Man(boolean smoking){super();this.smoking = smoking;}public  boolean getSmoking() {return smoking;}public  void setSmoking(boolean smoking) {this.smoking = smoking;}	public void ren(){System.out.println("我是男人");}public void game(){System.out.println("我要打游戏");}
}class Woman extends Person{private boolean beauty;public Woman(){super();}public Woman(boolean beauty){super();this.beauty = beauty;}public  boolean getBeauty() {return beauty;}public  void setBeauty(boolean beauty) {this.beauty = beauty;}	public void ren(){System.out.println("我是女人");}public void shopping(){System.out.println("我要购物");}
}
//测试
public class Test4{ public static void main(String[] args) {//子类对象的多态性: 父类的引用指向子类的对象Person p = new Man();//向上转型（子-->父）//虚拟方法调用p.ren();//Man的方法// p.game();此时的对象为Person类型，Person中无game()方法Person p1 = new Woman();p1.ren();//Woman的方法Woman w = (Woman)p1;//向下转型(使用强转符：父--->子）w.shopping();//instanceof判断某个对象是否属于某类的实例if(p instanceof Woman){Woman w1 = (Woman)p;w1.shopping();}if(p instanceof Man){Man m1 = (Man)p;m1.game();}if(p instanceof Person){System.out.println("carry!");}}
}

案例：

//父类
class Person{       private int age;private String name;public Person(){super();}public Person(String name,int age){super();this.age = age;this.name =name;}public  int 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 ren(){System.out.println("我是人类");}
}
//子类
class Man extends Person{ private boolean smoking;public Man(){super();}public Man(boolean smoking){super();this.smoking = smoking;}public  boolean getSmoking() {return smoking;}public  void setSmoking(boolean smoking) {this.smoking = smoking;}	public void ren(){System.out.println("我是男人");}public void game(){System.out.println("我要打游戏");}
}class Woman extends Person{private boolean beauty;public Woman(){super();}public Woman(boolean beauty){super();this.beauty = beauty;}public  boolean getBeauty() {return beauty;}public  void setBeauty(boolean beauty) {this.beauty = beauty;}	public void ren(){System.out.println("我是女人");}public void shopping(){System.out.println("我要购物");}
}
//测试
public class Test4{public static void main(String[] args) {Test4 t = new Test4();t.fun(new Person());t.fun(new Man());}public void fun(Person p){p.ren();}
}

练习
题一
在这里插入图片描述

题二
****

class GeometricObject{  private String color;private double weight;public GeometricObject(String color,double weight){this.color = color;this.weight = weight;}public void setColor(String color){this.color = color;}public String getColor(){return color;}public void setWeight(double weight){this.weight = weight;}public double getWeight(){return weight;}public double findArea(){return 0.0;}}
//子类
class Circle extends GeometricObject{private double radius;public Circle(double radius,String color,double weight){super(color,weight);this.radius = radius;}public double findArea(){return Math.PI * radius *radius;}public void setRadius(double radius){this.radius = radius;}public double getRadius(){return radius;}
}class MyRectangle extends GeometricObject{private double width;private double height;public MyRectangle(double width,double height,String color,double weight){super(color, weight);this.width = width;this.height = height;}public void setWidth(double width){this.width = width;}public double getWidth(){return width;}public void setHeight(double height){this.height = height;}public double getHeight(){return height;}public double findArea(){return height * width;}
}//测试
public class Test2{ public static void main(String[] args) {Test2 t = new Test2();Circle c = new Circle(2.3, "green", 1.0);MyRectangle m = new MyRectangle(2.3, 3.0, "green", 2.0);t.displayGeometricObject(c);t.displayGeometricObject(m);boolean a = t.Area(c, m);System.out.println(a);}public boolean Area(GeometricObject s1,GeometricObject s2){return s1.findArea() == s2.findArea();}public void displayGeometricObject(GeometricObject s){System.out.println("面积" + s.findArea());}
}

在这里插入图片描述
在这里插入图片描述

3. 其他关键字

this

  • this表示当前对象，可以调用类的属性,方法和构造器
    在这里插入图片描述
public class Test3 {                public static void main(String[] args) {Person p = new Person(); //Person()即为空参的构造器p.setAge(10);p.info();p.setName("小王");p.info();}
}class Person{private String name;private int age;//构造器public Person(){}public Person(String name){this.name = n;}public Person(String name,int age){this(name);//显示调用当前类的重载的指定的构造器this.age = a;}//方法public String getName(){return name;}public String getAge(){return age;}public void setAge(int a){age = a;}// public void setName(String n){// 	name = n;// }// public void setName(String name){ //调用此方法时，参数name与属性name混乱,name无法完成赋值操作// name = name;//  }public void setName(String name){ //this.name = name;}public void info(){System.out.println("name: " + name + "age: " + age);}
}

输出结果：
在这里插入图片描述

  • 在方法内部使用，即此方法所属对象的引用
  • 在构造器内部使用，表示该构造器正在初始化的对象
  • 在构造器中，可以使用"this(形参)"的方式显示调用本类其他重载的指定
  • 构造器
    必须声明在首行；
    如一个类中有n个构造器，那么最多可以有n-1个构造器可以使用this(形参)

练习
题一
在这里插入图片描述

//这些类可以写在不同的文件里
public class Test3 { public static void main(String[] args) {Boy boy = new Boy();boy.setAge(22);boy.setName("钱三一");Girl girl = new Girl();girl.setName("林妙妙");boy.marry(girl);boy.shout();System.out.println(" ");girl.marry(boy);}
}class Boy{  private String name;private int age;public void setName(String name){this.name = name;}public void setAge(int age){this.age = age;}public String getName( ){return name;}public String getAame( ){return age;}public void marry(Girl girl){System.out.println("我\u60F3要娶：" + girl.getName());}public void shout(){if(age > 24){System.out.println("我们可以先结婚");}else{System.out.println("\u6211\u4EEC可以先谈谈");}}
}class Girl{private String name;public void setName(String name){this.name = name;}public String getName(){return name;}public void marry(Boy boy){System.out.println("我想要嫁给：" + boy.getName());boy.marry(this);}
}

package

  • 声明源文件所在包，写在程序的第一行
  • 每"."一次，代表一层文件目录
  • 包名都要小写
  • package语句后面的分号不要掉

例：

package com.huwei.t1;（com是一个文件夹，huwei是com下的一个文件夹，t1是huwei文件夹下的一个文件夹)

个人的项目命名

indi
个体项目（individual），指个人发起，但非自己独自完成的项目，可公开或私有项目，copyright主要属于发起者。
包名为“indi.发起者名.项目名.模块名……”

onem
单人项目（one-man），推荐用indi，指个人发起，但非自己独自完成的项目，可公开或私有项目，copyright主要属于发起者。
包名为“onem.发起者名.项目名.模块名……”

pers
个人项目（personal），指个人发起，独自完成，可分享的项目，copyright主要属于个人。
包名为“pers.个人名.项目名.模块名.……”

priv
私有项目（private），指个人发起，独自完成，非公开的私人使用的项目，copyright属于个人。
包名为“priv.个人名.项目名.模块名.……”

团体的项目命名

team
团队项目，指由团队发起，并由该团队开发的项目，copyright属于该团队所有。
包名为“team.团队名.项目名.模块名.……”

com
公司项目，copyright由项目发起的公司所有。
包名为“com.公司名.项目名.模块名.……”

import

  1. 显式导入指定包下的类或接口
import java.util,Scanner;
  1. 写在包声明与源文件之间
  2. 如果引用多个类或接口，就需要并列写出
import java.util.Scanner;      
import java.util.Date;
  1. import语句后面的分号不要掉
  2. 程序默认导入的是java.lang下的所有类和接口(即System,int,Math等)，使用时不需要再次导入
  3. 导入一个包下的所有类可以使用*代替
import java.util.*;
  1. 同名类的导入（如util与sql下都有Date类）就需要用常规方法导入其中一个类，另一个同名的就直接用包名.类名表示

如：java.sql.Date d1 = new java.sql.Date(234435L)

  1. import satic 表示导入指定类的static的属性或方法

如：

引用：import java.lang.System.out;   
调用：out.println("hello world!")
  1. import java.util.* 只能导入java.util下的所有类和接口,不能导入lang下的子包中的类和接口。

super

可以修饰属性，方法，构造器

  • 若子类与父类中的属性有重名，可以用”super.属性“来显示调用父类声明中的属性，”this.属性“来显示调用子类声明中的属性。
  • 若子类与父类中的方法有重名，可以用”super.方法（）“来显示调用父类声明中的属性，”this.属性“来显示调用子类声明中的属性。
  • 在子类中使用”super(形参列表)“来显式调用父类中指定的构造器。
    在构造器内部，”super(形参列表)“必须声明在首行，
    在构造器内部，”super(形参列表)“和”this(参数列表)“只能存在其一，
    建议:设计一个类时，尽量要提供一个空参的构造器。
    在构造器中，不显示的调用”super(形参列表)“或”this(参数列表)“其中一个，那默认调用的是父类空参的构造器。）
    在这里插入图片描述
// 父类
class Person{                                                         private int sex; int id = 111;//身份证号public Person(int sex){ this.sex = sex; }public Person(){ System.out.println("我是父类空参构造器");}public  int getSex() {return sex; }public  void setSex(int sex) { this.sex = sex; }	public void manOrWorman(){ if(sex == 1){System.out.println("man"); }if(sex ==  0){ System.out.println("woman"); }}
}
//子类class Student extends Person{  private int yearOld; int id = 222;//学号 //子类调用父类的构造器public Student(int yearOld){ super(1); this.yearOld = yearOld; }public Student(){//此时程序也会调用父类空参的构造器this.yearOld = 33; }public void yearOld(int yearOld){ this.yearOld = yearOld; }public void printAge(){ System.out.println("yearOld: " + yearOld); }public void show(){ System.out.println(id);//222(子类) System.out.println(super.id);//111（父类） }}public class Test3{public static void main(String[] args) {Student student = new Student();student.setSex(0);student.yearOld(14);student.manOrWorman();student.printAge();student.show();}
}

感谢大家的支持，关注，评论，点赞！
参考资料：
尚硅谷宋红康20天搞定Java基础上部
Java包（package）的命名规范&规则

本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若转载，请注明出处：http://www.mzph.cn/news/29313.shtml

如若内容造成侵权/违法违规/事实不符，请联系多彩编程网进行投诉反馈email:809451989@qq.com，一经查实，立即删除！

相关文章

微前端初识

微前端初识

文章目录 微前端的发展历史微前端的定义微前端的特点使用微前端面临的挑战微前端常用技术方案及优缺点路由分发式微前端iframesingle-spaqiankunwebpack5: module federationWeb Component 微前端的发展历史 微前端在2016年首次出现在TWTR（ThoughtWorks Technology…
阅读更多...
MySQL之深入InnoDB存储引擎——Undo页

MySQL之深入InnoDB存储引擎——Undo页

文章目录 一、UNDO日志格式1、INSERT操作对应的UNDO日志2、DELETE操作对应的undo日志3、UPDATE操作对应的undo日志1）不更新主键2）更新主键的操作 3、增删改操作对二级索引的影响 二、UNDO页三、UNDO页面链表四、undo日志具体写入过程五、回滚段1、回滚段…
阅读更多...
java版直播商城平台规划及常见的营销模式 电商源码/小程序/三级分销+商城免费搭建 bbcbbc

java版直播商城平台规划及常见的营销模式 电商源码/小程序/三级分销+商城免费搭建 bbcbbc

​ Java版工程项目管理系统 Spring CloudSpring BootMybatisVueElementUI前后端分离 1. 涉及平台 平台管理、商家端（PC端、手机端）、买家平台（H5/公众号、小程序、APP端（IOS/Android）、微服务平台（业务服务…
阅读更多...
Mysql主从搭建 基于DOCKER

Mysql主从搭建 基于DOCKER

创建目录 #主节点目录 mkdir -p /home/data/master/mysql/#从节点目录 mkdir -p /home/data/slave/mysql/创建配置文件 # 主节点配置 touch /home/data/master/mysql/my.cnf# 从节点配置 touch /home/data/slave/mysql/my.cnf编辑配置文件 主节点配置文件 vim /home/data/m…
阅读更多...
算法通关村第五关——n数之和问题解析

算法通关村第五关——n数之和问题解析

1. 两数之和问题 力扣第1题就是两数之和问题，给定一个整数数组 nums 和一个整数目标值 target，请你在该数组中找出 和为目标值 target 的那两个整数，并返回它们的数组下标。你可以假设每种输入只会对应一个答案。但是，数组中同一…
阅读更多...
Ishikawa

Ishikawa

Ishikawa 石川、鱼骨头、因果 其实我压根不知道 Ishikawa 这个日文就是石川，^_^，视乎也没啥影响
阅读更多...
计算机网络基础

计算机网络基础

文章目录 网络协议初识协议分层OSI七层模型TCP/IP五层协议 网络传输基本流程网络传输流程数据包装和分用封装过程分用过程 网络中的地址管理IP地址MAC地址 网络协议初识 协议是一种约定。 协议分层 分层之后，每一层只关注自己同层的功能，只使用下层的接…
阅读更多...
卷积神经网络实现MNIST手写数字识别 - P1

卷积神经网络实现MNIST手写数字识别 - P1

🍨 本文为🔗365天深度学习训练营 中的学习记录博客🍦 参考文章：365天深度学习训练营-第P1周：实现mnist手写数字识别🍖 原作者：K同学啊 | 接辅导、项目定制🚀 文章来源：K同…
阅读更多...
【Hystrix技术指南】（1）基本使用和配置说明

【Hystrix技术指南】（1）基本使用和配置说明

这世间许多事物皆因相信而存在，所以人们亲手捏出了泥菩萨，却选择坚定的去信仰它。 分布式系统的规模和复杂度不断增加，随着而来的是对分布式系统可用性的要求越来越高。在各种高可用设计模式中，【熔断、隔离、降级、限流】是经常被…
阅读更多...
一个好的人力资源管理系统包括哪些部分

一个好的人力资源管理系统包括哪些部分

阅读本文，您将具体详细了解：一个好的人力资源管理系统应该包括哪些部分。 人事部门是一家公司重要的职能部门之一，为公司的持续性、健康性发展提供人力保障。 然而，目前传统的人事管理方式在应对一些问题时存在着一些挑战。 例…
阅读更多...
Shell脚本学习-循环的控制命令

Shell脚本学习-循环的控制命令

break continue exit对比&#xff1a; 示例1&#xff1a;break命令跳出整个循环。 [rootabc scripts]# cat break1.sh #!/bin/bashfor((i0;i<5;i)) doif [ $i -eq 3 ]thenbreakfiecho $i done echo "ok"[rootabc scripts]# sh break1.sh 0 1 2 ok可以看到i等于3及…
阅读更多...
jupyter lab环境配置

jupyter lab环境配置

1.jupyterlab 使用虚拟环境 conda install ipykernelpython -m ipykernel install --user --name tf --display-name "tf" #例&#xff1a;环境名称tf2. jupyter lab kernel管理 show kernel list jupyter kernelspec listremove kernel jupyter kernelspec re…
阅读更多...
微信小程序--原生

微信小程序--原生

1&#xff1a;数据绑定 1&#xff1a;数据绑定的基本原则 2&#xff1a;在data中定义页面的数据 3&#xff1a;Mustache语法 4&#xff1a;Mustache的应用场景 1&#xff1a;常见的几种场景 2&#xff1a;动态绑定内容 3&#xff1a;动态绑定属性 4&#xff1a;三元运算 4&am…
阅读更多...
C语言：打开调用堆栈

C语言：打开调用堆栈

第一步&#xff1a;打断点 第二步&#xff1a;FnF5 第三步&#xff1a;按如图找到调用堆栈
阅读更多...
C 语言高级3--函数指针回调函数，预处理，动态库的封装

C 语言高级3--函数指针回调函数，预处理，动态库的封装

目录 1.函数指针和回调函数 1.1 函数指针 1.1.1 函数类型 1.1.2 函数指针(指向函数的指针) 1.1.3 函数指针数组 1.1.4 函数指针做函数参数(回调函数) 2.预处理 2.1 预处理的基本概念 2.2 文件包含指令(#include) 2.2.1 文件包含处理 2.2.2 #incude<>和#include&q…
阅读更多...
C++ 线性群体的概念

C++ 线性群体的概念

线性群体中的元素次序与其位置关系是对应的。 在线性群体中&#xff0c;可以按照访问元素的不同方法分为直接访问、顺序访问和索引访问。 &#xff08;1&#xff09;直接访问 对可直接访问的线性群体&#xff0c;我们可以直接访问群体中的任何一个元素&#xff0c;而不必首先访…
阅读更多...
npm 报错 cb() never called!

npm 报错 cb() never called!

不知道有没有跟我一样的情况&#xff0c;在使用npm i的时候一直报错&#xff1a;cb() never called! 换了很多个node版本&#xff0c;还是不行&#xff0c;无法解决这个问题 百度也只是让降低node版本请缓存&#xff0c;gpt给出的解决方案也是同样的 但是缓存清过很多次了&a…
阅读更多...
Python中enumerate用法详解

Python中enumerate用法详解

目录 1.简介 2.语法 3.参数 4.返回值 5.详解 6.实例 7.补充 1.简介 enumerate() 函数用于将一个可遍历的数据对象(如列表、元组或字符串)组合为一个索引序列&#xff0c;同时列出数据和数据下标&#xff0c;一般用在 for 循环当中。 2.语法 以下是 enumerate() 方法的语…
阅读更多...
Linux 匿名页的生命周期

Linux 匿名页的生命周期

目录 匿名页的生成 匿名页生成时的状态 do_anonymous_page缺页中断源码 从匿名页加入Inactive lru引出 一个非常重要内核patch 匿名页何时回收 本文以Linux5.9源码讲述 匿名页的生成 用户空间malloc/mmap(非映射文件时&#xff09;来分配内存&#xff0c;在内核空间发生…
阅读更多...
【小梦C嘎嘎——启航篇】类和对象（中篇）

【小梦C嘎嘎——启航篇】类和对象（中篇）

【小梦C嘎嘎——启航篇】类和对象&#xff08;中篇&#xff09;&#x1f60e; 前言&#x1f64c;类的6个默认成员函数构造函数析构函数拷贝构造函数拷贝构造函数的特性有哪些&#xff1f;既然编译器可以自动生成一个拷贝构造函数&#xff0c;为什么我们还要自己设计实现呢&…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023