继承封装多态接口

第一章抽象和封装

1.1.创造类的对象

1.面向对象就是采用“现实模拟”的方法设计和开发程序。

PS（附录）：为什么要使用面向对象？

传统开发方法存在 A.软件重用性差 B.可维护性差 C.开发出的软件不能满足用户的需要

面向对象的优点：A.简单性 B.重用性高·开发效率高 C.容易修改和维护 D.结构明细·可读性强 E.安全性

//可以当作复习资料使用，要写详细认真点

 

2.面向对象设计的过程就是抽象的过程，根据业务需求，关注与业务现相关的属性和行为， 忽略不必要的属性和行为，由现实世界中“对象”抽象出软件开发中的“对象”。

 

3.面向对象设计的过程就是抽象的过程，我们分三步来完成。

第一步:发现类。

第二步：发现类的属性。

第三步：发现类的方法。

 

4.类：是从对象中抽取出来的共同特征，可以用它来创造对象，用同一个类创造的对象都拥有共同特征（你有的属性我也有，你有的方法我也有，但是可能属性里面的内容不一样）

 

5.所有Java程序都以类class为组织单元

关键字class定义自定义的数据类型

 

6.面向对象设计的过程就是抽象的过程，我们分三步来完成。

第一步:发现类。

第二步：发现类的属性。

第三步：发现类的方法。

 

7.使用对象的步骤

创建对象

类名 对象名 = new 类名();

引用对象成员：使用“.”进行以下操作

引用类的属性：对象名.属性

引用类的方法：对象名.方法名()

 

8.类(Class)和对象(Object)是面向对象中的两个核心概念。类是对某一类事物的描述， 是抽象的、概念上的定义。对象是实际存在的该事物的个体，是具体的、现实的。类和对 象就好比模具和铸件的关系，我们可以由一个类创建多 个对象。

Ps:类名和属性名和常量名的规范（没有好好记住的内容）

A类名由一个或几个单词组成，每个单词的第一个字母大写

B属性名和方法名由一个或几个单词组成，第一个单词首字母小写，其他单词首字母大 写

C常量名由一个或几个单词组成，所有字母大写（定义常量会不注意的细节）

 

9.static 可以用来修饰属性、方法和代码块。static 修饰的变量属于这个类所有，通常把 static 修饰的属性和方法称 为类属性(类变量)、类方法。不使用 static 修饰的属性和方法，属于单个对象，通常 称为实例属性(实例变量)、实例方法。

（类属性、类方法可以通过类名和对象名访问，实例属性、实例方法只能通过对象名访问。）

 

1.2构造方法及其重载

1.为什么要使用构造方法？

构造方法可以在创造对象的时候完成赋值操作

 

2.构造方法(Constructor)是一个特殊的方法，它用于创建类的对象，因此一个类必须包 含至少一个构造方法，否则就无法创建对象。当没有给构造方法的时候系统会主动给你构造方法，但是如果你给了构造方法，系统就不会给你构造方法（很多时候，我们会犯一个错误，给了有参数的构造方法，new对象的时候忘记给参数，想要调用无参构造方法，这时候会发生错误）

 

3.构造方法的名字和类名相同，没有返回类型。构造方法的作用主要就是在创建对象时执行 一些初始化操作，如给成员属性赋初值。

 

4.为什么要重载？(以构造方法为例）

为了在创造对象的时候完成不同属性的动态赋值

 

5.如果同一个类中包含了两个或两个以上方法，它们的方法名相同、方法参数个数或参数类 型不同，则称该方法被重载了，这个过程称为方法重载。成员方法和构造方法都可以进行 重载。

 

6.方法重载的判断依据如下： ²

必须是在同一个类里。 ²

方法名相同。 ²

方法参数个数或参数类型不同。 ²

与方法返回值和方法修饰符没有任何关系。（原来与返回值和修饰符无关！！！！理解误区）

 

Ps:构造方法没有返回值类型。如果有，就不是构造方法，而是和构造方法同名的成 员方法。

 

1.3封装

 

1.封装的概念：将类的状态信息隐藏在类的内部，不允许在类的外部直接访问，

而是通过 这个类提供的一些方法 来对属性进行操作以及访问

 

2.封装的好处：

可以方便地增加控制 存取属性值的语句，来避免对数据的不合理操作

 

3.封装时会用到多个权限控制符来修饰成员变量和方法，区别如下。 ² private：成员变量和方法只能在类内被访问，具有类可见性。 ²

默认：成员变量和方法只能被同一个包里的类访问，具有包可见性。 ² protected：可以被同一个包中的类访问，被同一个项目中不同包中的子类访问 public：可以被同一个项目中所有类访问，具有项目可见性，这是最大的访问权限。

 

4.修改属性的可见性来限制对属性的访问：

为每一个属性创造一对赋值（setter）方法和取值（getter)方法来对这些属性的存取。可以在其中加入控制语句

 

5.setter的语法：public void set属性名首字母大写（当前要涉资的属性类型 形参名）

{

this.属性 = 形参名；

}

Getter的语法：

Public 要获取的实例变量的类型 get要获取的实例变量名（）{
return 对应的属性值；

}

 

6.this 的作用² 使用 this 调用成员变量，解决成员变量和局部变量同名冲突。

 

7.注意： 因为 this 是在对象内部指代自身的引用，所以 this 只能调用实例变量、实例方法和构 造方法。 ²

this 不能调用类变量和类方法。 ²

this 也不能调用局部变量。

 

 

 

 

第二章继承

2.1

1.为什么要继承？

继承可以避免代码重复，也方便日后代码的修改？

 

2.继承(Inheritance)通过 extends 关键字来实现

被继承的类可以叫做父类，基类或者超类

 

3.注意：修饰符如果是 public，该类在整个项目中 可见；不写 public 修饰符则该类只在当前包可见；不可以使用 private 和 protected 修饰类。

 

4.Java 中只支持单 一继承，即每个类只能有一个直接父类。但是可以有很多个间接父类，所以不可以说只能有一个父类

 

5.继承表达的是 is a 的关系，或者说是一种特殊 和一般的关系，例如 Dog is a Pet（注意，我不知道怎么使用is a)

 

6.在 Java 中，所有的 Java 类都直接或间接地继承了 java.lang.Object 类。Object 类是所有 Java 类的祖先。在定义一个类时，没有使用 exteds 关键字，那么这个类直接 继承 Object 类。

 

7.在 Java 中，子类可以从父类中继承哪些“财产”呢？ ²

继承 public 和 protected 修饰的属性和方法，不管子类和父类是否在同一个包里。 ²

继承默认权限修饰符修饰的属性和方法，但子类和父类必须在同一个包里。 ² 无法继承 private 修饰的属性和方法。

无法继承父类的构造方法。

 

2.2子类重写父类方法

1.为什么要重写?

如果从父类继承的方法不能满足子类的需求，在子类中可以对父类的同名方法进行重写 (覆盖)，以符合需求。

 

2.概念：在子类中可以根据需求对从父类继承的方法进行重新编写，称为方法的重写或方法的覆盖

 

3.方法重写必须满足如下要求。

重写方法和被重写方法必须具有相同的方法名。 ²

重写方法和被重写方法必须具有相同的参数列表。 ²

重写方法的返回值类型必须和被重写方法的返回值类型相同或者是其子类。 ²重写方法的不能缩小被重写方法的访问权限。（只能扩大，比如父类是包权限，其子类就得是包权限或者公开）

 

问题：重载(overloading)和重写(overriding)有什么区别和联系？

解答：重载涉及同一个类中的同名方法，要求方法名相同，参数列表不同，与返回值类型 无关。（与修饰符也无关，最大的区别是在不在一个类中） 

重写涉及的是子类和父类之间的同名方法，要求方法名相同、参数列表相同、返回值类型 相同(或是其子类)。

 

4.super 代表对当前对象的直接父类对象的默认引用。。在子类中可以通过 super 关键字来 访问父类的成员。

 

5.supper注意点：

super 必须是出现在子类中(子类的方法和构造方法中)，而不是其他位置。 ² 可以访问父类的成员，例如父类的属性、方法、构造方法。 ²

注意访问权限的限制，例如无法通过 super 访问 private 成员。

 

super.name; // 访问直接父类的 name 属性(如果 name 是 private 权 限，则无法访问)。 ²

super.print(); // 访问直接父类的 print()方法。 ²

super(name); // 访问直接父类的对应构造方法，只能出现在构造方法中。

 

在构造方法和非构造方法中的this与supper

在构造方法中如果有 this 语句或 super 语句出现，只能是第一条语句。 ²

在一个构造方法中不允许同时出现 this 和 super 语句(否则就有两条第一条语句)。 ²

在类方法中不允许出现 this 或 super 关键字。 ²

在实例方法中 this 和 super 语句不要求是第一条语句，可以共存。

 

 

2.3 抽象类和 final

1.抽象类

定义一个抽象类是为了在发挥父类的作用下限制他不可以实例化

 

2.抽象类和抽象方法都通过 abstract 关键字来修饰。 抽象类不能实例化。

 

3.抽象类中可以没有、可以有一个或多个抽象方法，甚至可以全部方法 都是抽象方法。但是一旦有抽象方法，那么他就是抽象类

 

4.抽象方法只有方法声明，没有方法实现。形式如：public abstract void print();

有抽象方法的类必须声明为抽象类。子类必须重 写所有的抽象方法才能实例化，否则子类还是一个抽象类。

 

5.abstract 可以用来修饰类和方法，但不能用来修饰属性和构造方法。(没有注意到的细节）

 

6.用 final 修饰的类，不能再被继承。

用 final 修饰的方法，不能被子类重写。

用 final 修饰的变量(包括成员变量和局部变量)将变成常量，只能赋值一次。

final 可以用来修饰类、方法和属性，不能修饰构造方法。

 

7.使用abstract注意点：

(A)抽象关键字，是否可以和final关键字一起使用？

 不能，因为abstract关键字 是要求子类一定要重写父类的方法，但是final是不允许重写的

 

 (B)抽象关键字，是否可以和private关键字一起使用？

 不能，因为private是私有的，不能被继承的内容，代表根本不存在方法重写，因此不能一起使用

 

 (C)抽象关键字，是否可以和static一起使用？

 不能，因为static是静态修饰符，代表不需要实例化对象，直接用类名就可以调用方法， 那么如果是抽象方法，没有方法实现

 调用方法会出错，所以编译器禁止 abstract和static一起使用

 

 (D) 构造方法不允许被继承，所以也没有重写， 不能用abstract修饰

 

 

 

第 3 章 多 态

3.1

多态的作用就是为了减少代码量

1.多态： 一个对象 的多种状态

 

2.多态的三要素：

一定要有继承

一定要重写

父类的指针，指向子类的对象

例如L：Pet pet=new Dog（）；

 

3.出子类转换成父类时的规则。（我们最常用在：使用父类作为方法形参实现多态） ²

将一个父类的引用指向一个子类对象，称为向上转型(upcasting)，自动进行类型 转换。 ²

此时通过父类引用变量调用的方法是子类覆盖或继承父类的方法，不是父类的方法。 ²

此时通过父类引用变量无法调用子类特有的方法。（这时候你想调用子类特有方法，这就涉及了父类到子类的转换，同时会使用 instanceof 运算符来判断对象的类型。）

 

4.父类到子类的转换，向下转型。将一个指向子类对象的父类引用付给一个子类的引用，称为向下转型，必须强制

类型转换：对象向下转型：子类 子类对象 = （子类）父类实例//为了让这个对象能够使用子类特有的方法才做的

（这时候就是都能用）

规矩A：类型匹配

规矩B：父类本身就指向这个子类

 

 

3.2. instanceof 运算符

1.对象 instanceof 类或接口  

该运算符用来判断一个对象是否属于一个类或者实现了一个接口，结果为 true 或 false

 

2.用于：在强制类型转换之前通过 instanceof 运算符检查对象的真实类型，然后再进行相应的 强制类型转换，这样就可以避免类型转换异常，从而提高代码健壮性。

 

 

第 4 章 接 口

1.接口与抽象类

如果抽象类中所有的方法都是抽象方法，就可以使 用 Java 提供的接口来表示。从这个角度来讲，接口可以看作是一种特殊的“抽象类”， 但是采用与抽象类完全不同的语法来表示，两者的设计理念也是不同的

 

2.和类实现接口的语法

[修饰符] interface 接口名 extends 父接口 1,父接口 2,……

{

常量定义 方法定义

}

3.接口：

A.接口和类、抽象类是一个层次的概念，命名规则相同。如果修饰符是 public，则该 接口在整个项目中可见，如果省略修饰符，则该接口只在当前包可见。

B.接口中可以定义常量，不能定义变量。接口中属性都会自动用 public static final（常量要用全部大写）

即接口中属性都是全局静态常量。接口中的常量必须在定义时指定初始值

C.接口中所有方法都是抽象方法。接口中方法都会自动用 public abstract 修饰， 即接口中只有全局抽象方法。

D.和抽象类一样，接口同样不是实例化，接口中不能有构造方法。（抽象类有构造方法）

E.接口之间可以通过 extends 实现继承关系，一个接口可以继承多个接口，但接口不 能继承类。

F.一个类只能有一个直接父类，但可以通过 implements 实现多个接口。类必须实现 接口的全部方法，否则必须定义为抽象类。类在继承父类的同时又实现了多个接口时， extends 必须位于 implements 之前。（没有注意的细节）

 

4. 接口表示一种能力和约束（因为你必须实现接口所有方法）

5.接口的多态

或者是 接口的引用类型变量 指向 接口实现类 的对象

接口实现类 ---》 就是实现了这个接口的类

 

6.接口的多态实现：

(1)要有接口

（2）要有 接口的实现类

（3）要让接口的引用类型变量 指向 接口实现类 的对象

 

 

面向对象六大准则

1.单一职能原则

2.接口隔离原则

3.开闭原则

4.里氏替换原则

5.迪米特法则

 

单一职能原则：是指一个类的功能要单一，不能包罗万象。一个类只负责一个职责

接口隔离原则：在编写程序中，要用专门的接口，多个专门的借口都要比单一的总接口好，这样子调用者就只访问它自己的方法，不会访问它不应该访问的方法了

开闭原则：对拓展开放，对修改关闭

里氏替换原则：子类可以替换父类并且出现在父类能够出现的任何地方

（子类通过实现了父类接口，能够替父类的使用地方！）

迪米特法则：一个类应该对自己需要耦合或调用的类（朋友类）知道得最少。而所谓的朋友类是指你在方法中以形参传进的类，在本类中可以使用朋友类公开的方法。

总结：都是为了降低耦合性

 

 

 

类与类之间的关系

1.继承关系   ：   继承指的是一个类（称为子类、子接口）继承另外的一个类

（称为父类、父接口）的功能，并可以增加它自己的新功能的能力。在Java中继承关系通过关键字extends明确标识

2.实现关系   :   实现指的是一个class类实现interface接口（可以是多个）的功能，实现是类与接口之间最常见的关系。在Java中此类关系通过关键字implements明确标识

3.依赖关系 :  一个类A使用到了另一个类B，而这种使用关系是具有偶然性的、临时性的、非常弱的，但是类B的变化会影响到类A(代码层面，为类B作为参数被类A在某个method方法中使用)

4.关联关系  关联体现的是两个类之间语义级别的一种强依赖关系，比如我和我的朋友，这种关系比依赖更强、不存在依赖关系的偶然性、关系也不是临时性的，一般是长期性的，而且双方的关系一般是平等的(代码层面，为被关联类B以类的属性形式出现在关联类A中)

A.组合关系    : 组合也是关联关系的一种特例，它体现的是一种contains-a的关系，这种关系比聚合更强，也称为强聚合。它同样体现整体与部分间的关系，但此时整体与部分是不可分的，整体的生命周期结束也就意味着部分的生命周期结束，比如人和人的大脑。表现在代码层面，和关联关系是一致的

B.聚合关系     :聚合是关联关系的一种特例，它体现的是整体与部分的关系，即has-a的关系。此时整体与部分之间是可分离的，它们可以具有各自的生命周期

注意：不太理解组合与聚合。

关于陈梦芳的代码我只记得他的代码只实现了攻击接口的多态