正文

day6面向对象

Michael2397  Michael2397  2022-08-08  416

关键词：

继承

1.1 类和类之间的常见关系。

1：既然继承是描述类和类之间的关系，就需要先来了解类和类之间的常见关系

1.1.1 现实生活的整体与部分

举例说明

1：现实生活

1：学生是人

2：狗是动物

3：球队包含球员整体与部分的关系，部分可以删除和增加

4：笔记本包含 cpu 整体与部分的关系，部分不可以删除和增加

5：航母编队包含（航母护卫舰驱逐舰舰载机核潜艇）

1.1.2 java中的类与类关系

java中的类关系

1：is a 关系 (学生是人)

2：has a 整体与部分

 1 class Person{
 2     String name;
 3     int age;
 4     Address add;
 5     
 6     Person(){
 7         
 8     }
 9     Person(String name,int age,Address add){
10         
11         this.name=name;
12         this.age=age;
13         this.add=add;
14         
15     }
16     
17     void speak(){
18         System.out.println("姓名："+name+" 年龄："+age+" "+add.print());
19     }
20 }
21 class Address{
22     String country;
23     String city;
24     String street;
25     
26     Address(){
27     
28     }
29     Address(String country,String city,String street){
30         this.country=country;
31         this.city=city;
32         this.street=street;
33     }
34     
35     String print(){
36         return "地址："+country+" "+"城市："+city+"  街道；"+street;
37     }
38 }
39 class Demo3{
40 
41     public static void main(String[] args){
42         
43         Address add=new Address("中国","广州","棠东东路");
44         Person p=new Person("jack",27,add);
45         p.speak();
46         
47         
48         System.out.println();
49          }
50 }
51

View Code

继承

1：描述一个学生类

1：姓名年龄学号属性，学习的方法

2：描述一个工人类

1：姓名年龄工号属性，工作的方法

3：描述一个人类

1：姓名年龄属性，说话的方法。

　　4：发现学生类和人类天生有着联系，学生和工人都是人。所以人有的属性和行为学生和工人都会有。出现类代码重复

 1 class Person {
 2     String name;
 3     int age;
 4 
 5     // 静态变量（类变量）对象和对象之间的代码重复使用静态变量
 6     static String country = "CN";
 7 
 8     Person() {
 9 
10     }
11 
12     void speak() {
13         System.out.println(name + ":哈哈，我是人！！！");
14     }
15 
16 }
17 
18 // 让学生类和人类产生关系，发现学生is a 人，就可以使用继承
19 class Student {
20 
21     String name;
22     int age;
23 
24     Student() {
25 
26     }
27 
28     void study() {
29         System.out.println("姓名：" + name + "年纪：" + age + ":好好学习");
30     }
31 }
32 
33 class Worker {
34     String name;
35     int age;
36 
37     void work() {
38         System.out.println(name + ":好好工作，好好挣钱。");
39     }
40 
41 }
42 
43 class Demo1 {
44 
45     public static void main(String[] args) {
46         Student s = new Student();
47         s.name = "jack";
48         s.age = 20;
49         s.study();
50 
51         Worker w = new Worker();
52         w.name = "rose";
53 
54         w.work();
55     }
56 }

View Code

5：问题:

1：如果没有继承,出现类和类的关系无法描述

2：如果没有继承，类和类之间有关系会出现类和类的描述代码的重复。

继承特点

1：描述类和类之间的关系

2：降低类和类之间的重复代码

　　1：降低对象和对象之间的代码重复使用静态变量

2：降低类和类之间的代码重复使用就继承

extends关键字

继承使用extends关键字实现

1：发现学生是人，工人是人。显然属于is a 的关系，is a就是继承。

2：谁继承谁？

学生继承人，发现学生里的成员变量，姓名和年龄，人里边也都进行了定义。有重复代码将学生类的重复代码注释掉，创建学生类对象，仍然可以获取到注释的成员。这就是因为继承的关系，学生类（子类）继承了人类（父类）的部分

 1 class Person {
 2     String name;
 3     int age;
 4 
 5     // 静态变量（类变量）对象和对象之间的代码重复使用静态变量
 6     static String country = "CN";
 7 
 8     Person() {
 9 
10     }
11 
12     void speak() {
13         System.out.println(name + ":哈哈，我是人！！！");
14     }
15 
16 }
17 
18 // 让学生类和人类产生关系，发现学生is a 人，就可以使用继承
19 class Student extends Person {
20 
21     Student() {
22 
23     }
24 
25     void study() {
26         System.out.println("姓名：" + name + "年纪：" + age + ":好好学习");
27     }
28 }
29 
30 class Worker extends Person {
31 
32     void work() {
33         System.out.println(name + ":好好工作，好好挣钱。");
34     }
35 
36 }
37 
38 class Demo1 {
39 
40     public static void main(String[] args) {
41         Student stu = new Student();
42         stu.name = "jack";
43         stu.age = 20;
44         stu.study();
45         stu.speak();
46         System.out.println(stu.country);
47         System.out.println(Student.country);
48 
49         Worker worker = new Worker();
50         worker.name = "rose";
51         System.out.println(worker.country);
52         worker.work();
53         worker.speak();
54 
55         System.out.println();
56     }
57 }

View Code

继承细节；

1：类名的设定，被继承的类称之为父类(基类)，继承的类称之为子类

2：子类并不能继承父类中所有的成员

1：父类定义完整的成员静态成员，非静态，构造方法。静态变量和静态方

法都可以通过子类名.父类静态成员的形式调用成功。

2：所有的私有成员不能继承,private修饰的成员。

3：构造函数不能被继承

3：如何使用继承

1：不要为了使用继承而继承。工人和学生都有共性的成员，不要为了节省代

码，让工人继承学生。

 1 /*
 2 如何使用继承：验证是否有 is  a 的关系
 3  例如：学生是人， 小狗是动物
 4  注意：不要为了使用某些功能而继承,java只支持单继承
 5  */
 6 class DK {
 7 
 8     void Ip4S() {
 9         System.out.println("好玩");
10     }
11 }
12 
13 class BGir extends DK {
14 
15 }
16 
17 class Demo {
18 
19     public static void main(String[] args) {
20 
21         new BGir().Ip4S();
22 
23     }
24 }

View Code

super关键字

1：定义Father(父类)类

1：成员变量int x=1;

2：构造方法无参的和有参的，有输出语句

2：定义Son类extends Father类

1：成员变量int y=1;

2：构造方法无参和有参的。有输出语句

1：this.y=y+x;

3：创建Son类对象

Son son=new Son(3);

System.out.println(son.y); //4

 1 class Father {
 2     int x = 1;
 3 
 4     Father() {
 5         System.out.println("这是父类无参构造");
 6     }
 7 
 8     Father(int x) {
 9 
10         this.x = x;
11         System.out.println("这是父类有参构造");
12     }
13 
14     void speak() {
15         System.out.println("我是父亲");
16     }                  
17 }
18 
19 class Son extends Father {
20     int y = 1;
21 
22     Son() {
23         System.out.println("这是子类的无参构造");
24     }
25 
26     Son(int y) {
27 
28         this.y = y + x;
29         System.out.println("这是子类的有参构造");
30     }
31 
32     void run() {
33         super.speak(); // 访问父类的函数
34         System.out.println("我是儿子");
35     }
36 }
37 
38 class Demo6 {
39 
40     public static void main(String[] args) {
41         Son s = new Son(3);
42         System.out.println(s.y);// 4
43     }
44 }

View Code

　　4：子类对象为什么可以访问父类的成员。

1：this.y=y+x;有一个隐式的super super.x

　　5：super关键字作用

1：主要存在于子类方法中，用于指向子类对象中父类对象。

2：访问父类的属性

3：访问父类的函数

4：访问父类的构造函数

　　6：super注意

　　　this和super很像，this指向的是当前对象的调用，super指向的是当前调用对象的父类。Demo类被加载，执行main方法，Son.class加载，发现有父类Father类，于是Father类也加载进内存。类加载完毕，创建对象，父类的构造方法会被调用（默认自动无参），然后执行子类相应构造创建了一个子类对象，该子类对象还包含了一个父类对象。该父类对象在子类对象内部。this super只能在有对象的前提下使用，不能在静态上下文使用。

　　子类的构造函数默认第一行会默认调用父类无参的构造函数，隐式语句

　　　　super();

1：父类无参构造函数不存在，编译报错。

1 Son(int y) {
2         //super();隐式语句
3         this.y = y + x;
4         System.out.println("这是子类的有参构造");
5     }

View Code

　　子类显式调用父类构造函数

　　在子类构造函数第一行通过super关键字调用父类任何构造函数。如果显式调用父类构造函数，编译器自动添加的调用父类无参数的构造就消失。构造函数间的调用只能放在第一行，只能调用一次。super() 和this()不能同时存在构造函数第一行。

 1 Son(int y) {
 2         super(y);// 子类显式调用父类构造函数
 3         this.y = y + x;
 4         System.out.println("这是子类的有参构造");
 5     }
 6 
 7 Son(int y) {
 8         this();  //不能同时存在构造函数第一行  
 9         super(y);
10         this.y = y + x;
11         System.out.println("这是子类的有参构造");
12     }

View Code

super思考

如果开发者自定义了一个类，没有显示的进行类的继承，那么该类中成员函数是否可以使用super关健健字？可以使用，继承了Object类，Object类是所有类的父类。

1 class Demo7 {
2     public  void print(){
3         System.out.println(super.toString());
4     }
5     public static void main(String[] args){
6         new Demo7().print();
7         System.out.println();
8          }
9 }

View Code

7：重写（Override）

1：定义Father类

1：姓名，吃饭方法，吃窝窝头。

2：定义Son类，继承Father

1：Son类中不定义任何成员，子类创建对象，仍然可以调用吃饭的方法。

2：父类的吃饭的方法，Son不愿吃。Son自己定义了吃饭的方法。

1：此时父类中有一个吃饭的方法，子类中有2个吃饭的方法，一模一样，只是方法体不一样。

2：一个类中两个函数一模一样，是不允许的。

1：编译运行，执行了子类的方法。

2：使用父类的方法，在子类方法中，使用super.父类方法名。

 1 class Father {
 2     String name;
 3 
 4     void eat() {
 5         System.out.println("吃窝窝");
 6     }
 7 }
 8 
 9 class Son extends Father {
10 
11     public void eat() { // 继承可以使得子类增强父类的方法
12         System.out.println("来俩小菜");
13         System.out.println("来两杯");
14         System.out.println("吃香喝辣");
15             System.out.println("来一根");
16     }
17 }
18 
19 class Demo8 {
20 
21     public static void main(String[] args) {
22         Son s = new Son();
23         //执行子类的方法
24         s.eat();
25 
26     }
27 }

View Code

3：该现象就叫做重写(覆盖 override)

1：在继承中，子类可以定义和父类相同的名称且参数列表一致的函数，将这种函数

称之为函数的重写.

4：前提

1：必须要有继承关系

5：特点

1：当子类重写了父类的函数，那么子类的对象如果调用该函数，一定调用的是重写过后的函数。

可以通过super关键字进行父类的重写函数的调用。

2：继承可以使得子类增强父类的方法

6：细节

1：函数名必须相同

2：参数列表必须相同

　　3：子类重写父类的函数的时候，函数的访问权限必须大于等于父类的函数的访

问权限否则编译报错

　　4：子类重写父类的函数的时候，返回值类型必须是父类函数的返回值类型或该返回值类型的子类。不能返回比父类更大的数据类型：如子类函数返回值类型是Object

1：定义 A B C 类 B extends A

2：Father类中定义A getA();

3：Son 类中重写getA(); 方法，尝试将返回值修改为B，C ,Object

1：B编译通过

2：C 编译失败 ,没有继承关系

3：Object编译失败,比父类的返回值类型更大

1：定义 A B C 类 B extends A

2：Father类中定义A getA();

3：Son 类中重写getA(); 方法，尝试将返回值修改为B，C ,Object

1：B编译通过

2：C 编译失败 ,没有继承关系

3：Object编译失败,比父类的返回值类型更大

 1 class A {
 2 
 3 }
 4 
 5 class B extends A {
 6 
 7 }
 8 
 9 class C {
10 
11 }
12 class Father {
13     String name;
14 
15     void eat() {
16         System.out.println("吃窝窝");
17     }
18 
19     // 定义一个函数，获取A类的对象，
20     A getA() {
21         return new A();
22     }
23 
24 }
25 
26 class Son extends Father {
27 
28     public void eat() { // 继承可以使得子类增强父类的方法
29         System.out.println("来两杯");
30         System.out.println("来俩小菜");
31         super.eat();
32         System.out.println("来一根");
33     }
34 
35     // B类是A类的子类
36     B getA() {
37         return new B();
38     }
39 }
40 
41 class Demo8 {
42 
43     public static void main(String[] args) {
44         Son s = new Son();
45         s.eat();
46 
47     }
48 }

View Code

7：子类对象查找属性或方法时的顺序：

1：原则：就近原则。

如果子类的对象调用方法，默认先使用this进行查找，如果当前对象没有找到属性或方法，找当前对象中维护的super关键字指向的对象，如果还没有找到编译报错，找到直接调用。

8：重载和重写的不同

1：重载(overload)：

1：前提：所有的重载函数必须在同一个类中

2：特点：

函数名相同，参数列表不同，与其他的无关(访问控制符、返回值类型)

3：不同：

个数不同、顺序不同、类型不同

2：重写(override)：

1：前提：继承

2：特点：

函数名必须相同、参数列表必须相同。

子类的返回值类型要等于或者小于父类的返回值

9：重写练习

描述不同的动物不同的叫法

1：定义动物类

有名字，有吃和叫的方法

2：定义狗继承动物重写父类吃和叫的方法

3：定义猫继承动物重写父类吃和叫的方法

 1 class Animal{
 2     int x=1;
 3     String name;
 4     
 5     void eat(){
 6         System.out.println("吃东西");
 7     }
 8     void shout(){
 9         System.out.println("我是动物");
10     }
11 }
12 
13 class Dog extends Animal{
14     
15     
16     void eat(){
17         System.out.println("啃骨头");
18     }
19     void shout(){
20         System.out.println("旺旺");
21     }
22     void eat(String food){
23         System.out.println("吃："+food);
24     }
25 }
26 class Cat extends Animal{
27 
28     void eat(){
29         System.out.println("吃老鼠");
30     }
31     void shout(){
32         System.out.println("喵喵");
33     }
34 }
35 
36 class Demo9{
37 
38     public static void main(String[] args){
39         Dog d=new Dog();
40         d.shout();
41         d.eat();
42         
43         Cat c=new Cat();
44         c.shout();
45         c.eat();
46         System.out.println();
47          }
48 }

View Code

instanceof 关键字

1：快速演示instanceof

1 Person p=new Person();
2         System.out.println( p instanceof Person);

View Code

2：instanceof是什么？

1：属于比较运算符：

2：instanceof关键字：该关键字用来判断一个对象是否是指定类的

day6

Python面向对象Python从设计之初就已经是一门面向对象的语言，正因为如此，在Python中创建一个类和对象是很容易的。本章节我们将详细介绍Python的面向对象编程。如果你以前没有接触过面向对象的编程语言，那你可能需要先了解... 查看详情

day6面向对象编程

面向对象编程介绍OOP编程是利用“类”和“对象”来创建各种模型来实现对真实世界的描述，使用面向对象编程的原因一方面是因为它可以使程序的维护和扩展变得更简单，并且可以大大提高程序开发效率，另外，... 查看详情

day6面向对象基础(代码片段)

　　java面向对象　　面向对象思想：　　1.设计类，并设计类的成员（成员变量&成员方法）;　　 2.通过类，来创建类的对象（也称作类的实例化）;　　3.通过“对象.属性”或“对象.方法”来调用，完成相应的功能；　... 查看详情

day6-面向对象学习

面向对象介绍特性classobject封装继承https://segmentfault.com/a/1190000002685939python2经典类是按照深度优先来继承的；新式类是按照广度优先继承的。python3经典类，新式类都是按照广度优先来继承的多态语法属性方法构造函数析... 查看详情

面向对象的程序设计(day6)

一、面向过程与面向对象面向过程：核心是过程二字，过程即解决问题的步骤，就是先干什么再干什么基于该思想写程序就好比在设计一条流水线，是一种机械式的思维方式优点：复杂的过程流程化，进而简单化缺点：扩展性差... 查看详情

day6面向对象

继承1.1 类和类之间的常见关系。 1：既然继承是描述类和类之间的关系，就需要先来了解类和类之间的常见关系1.1.1 现实生活的整体与部分举例说明1：现实生活 1：学生是人&nbs... 查看详情

day6面向对象--继承多态

继承继承：就像遗传一样，继承就是拥有父类的所有方法和属性，并且能够定义自己独特的属性和方法，对上面的类进行扩展。可以什么都不写，直接继承父类，如下： classPeople(object):def_... 查看详情

day6面向对象--类的特殊成员方法

类的特殊成员方法 1.__doc__　　表示类的描述信息classFunc(object):‘‘‘__doc__方法是用来打印类的描述信息‘‘‘deftell(self):passdefenroll(self):passprint(Func.__doc__)#输出：类的描述信息运行结果如下：__doc__方法是用来打印类... 查看详情

day6心得

面向对象编程介绍为什么要用面向对象进行开发？面向对象的特性：封装、继承、多态类、方法、引子你现在是一家游戏公司的开发人员，现在需要你开发一款叫做<人狗大战>的游戏，你就思考呀，人狗作战，那至... 查看详情

java核心面试宝典day6面向对象常见面试题汇总(代码片段)

Hello，你好呀，我是灰小猿！一个超会写bug的程序猿！用坚持缔造技术、用指尖敲动未来！和很多小伙伴们一样，我也是一名奔波在Java道路上的“创造者”。也想靠技术来改未来，改变世界！因为... 查看详情

java核心面试宝典day6面向对象常见面试题汇总(代码片段)

day6老王开枪打人

...main():‘‘‘用来控制这个程序的流程‘‘‘pass#1.创建alex对象#2.创建1个枪对象#3.创建1个弹夹对象#4.创建子弹对象#5.创建一个敌人#6.alex把子弹安装到弹夹中#7.alex把弹夹安装到枪中#8.alex拿枪#9.alex拿枪打jackif__name__=="__main__":main()&nb... 查看详情

go(day6[接口])

Go接口Interface定义:Interface类型可以定义?组?法，?来表示?个对象的?为特征。interface不能包含任何变量。查看详情

day6面相对象编程类的继承经典类新式类

类变量与实例变量构造函数__author__=‘meng‘classFoo:#n=12345#类变量def__init__(self,name,age):#构造函数#在实例化时做一些类的初始化工作self.name=name#实例变量（静态属性），作用域就是实例本身self.age=agedefshot(self):#类的方法功能（动态... 查看详情

改善程序与设计的55个具体做法day6

条款13：以对象管理资源资源，包括但不限于内存、句柄、GDI对象、数据库连接等。内存要记得释放，句柄要记得closehandle，GDI对象要记得删除，数据库连接要记得关闭，等等等等。以对象来管理这些资源就是利用对象的构... 查看详情

day6java学习第六天---;方法

...方法System.out.println(),那它是什么？调用System系统类中的out对象的println()方法Java方法是语句的集合，它们在一起执行一个功能。方法是解决一类问题的步骤的有序组合方法包含于类或对象中方法查看详情

day6.列表函数

1.list.append(obj) 在列表末尾添加新的对象2.list.count(obj) 统计某个元素在列表中出现的次数3.list.extend(seq) 在列表末尾一次性追加另一个序列中的多个值（用新列表扩展原来的列表）4.list.index(obj) 从... 查看详情

day6_time模块

...特定的格式输出时间print(time.localtime())　　#得到的是一个对象，如果想要看下面的子模块，看哪个模块就在后边加上（.模块）就好，一定不要忘了点print(time.localtime())#time.str 查看详情