本文是通过阅读大话设计模式后，记录重要知识，然后做成笔记内容的。
《重构与模式》中有一句经典之语：“如果想成为一名更优秀的软件设计师，了解优秀软件设计的演变过程比学习优秀设计本身更有价值，因为设计的演变过程中蕴藏着大智慧。
一，面向对象基础知识
1 ，类与实例
对象是什么？类是什么?
-
一切事物皆为对象，即所有的东西都是对象，对象就是可以看到、感觉到、听到、触摸到、尝到、或闻到的东西。准确地说，对象是一个自包含的实体，用一组可识别的特性和行为来标识。 面向对象编程，英文叫Object-Oriented Programming，其实就是针对对象来进行编程的意思。
-
类就是具有相同的属性和功能的对象的抽象的集合
举例:
public class Cat {
public String Shout(){
return "喵";
}
}
@Test
public void button1_Click(){
Cat cat = new Cat();
System.out.println(cat.Shout());
}
这里 ‘class’ 是表示定义类的关键字，‘Cat’ 就是类的名称，‘Shout’ 就是类的方法。
注意：
- 类名称首字母记着要大写。多个单词则各个首字母大写；
- 对外公开的方法需要用 ‘public’ 修饰符。”
实例化：
- 实例，就是一个真实的对象。比如我们都是‘人’，而你和我其实就是‘人’类的实例了。而实例化就是创建对象的过程，使用new关键字来创建。
注意： 将Cat实例化,其实做了两件事:
//将Cat实例化
Cat cat = new Cat();
//1，声明一个Cat对象，对象名为cat
Cat act;
//2，将此cat对象实例化
cat = new Cat();
Cat实例化后，等同于出生了一只小猫cat，此时就可以让小猫cat.Shout()了。在任何需要小猫叫的地方都可以实例化它。
2，构造方法
-
构造方法: 又叫构造函数，其实就是对类进行初始化。构造方法与类同名，无返回值，也不需要void，在new时候调用。
-
所有类都有构造方法，如果你不编码则系统默认生成空的构造方法，若你有定义的构造方法，那么默认的构造方法就会失效了。
举例:
public class Cat {
//构造方法
//声明Cat类的私有字符串变量name
private String name="";
//定义Cat类的方法，参数是输入一个字符串
public Cat(String name){
//将参数赋值给私有变量name
this.name = name;
}
//类的方法
public String Shout(){
return "我的名字叫" + name + "，我会"+"喵";
}
}
@Test
public void button1_Click(){
Cat cat = new Cat("小黑");
System.out.println(cat.Shout());
}
构造方法快捷键：Alt + Insert
联想电脑：Fn + Alt + Insert
3，方法重载
-
方法重载： 提供了创建同名的多个方法的能力，但这些方法需使用不同的参数类型。
-
并不是只有构造方法可以重载，普通方法也可以重载。
public class Cat {
//构造方法
//声明Cat类的私有字符串变量name
private String name="";
//定义Cat类的方法，参数是输入一个字符串
public Cat(String name){
//将参数赋值给私有变量name
this.name = name;
}
//方法重载
public Cat(){
this.name="无名";
}
//类的方法
public String Shout(){
return "我的名字叫" + name + "，我会"+"喵";
}
}
注意：
- 方法重载时，两个方法必须要方法名相同，但参数类型或个数必须要有所不同，
好处：
- 方法重载可在不改变原方法的基础上，新增功能。
4，属性与修饰符
-
属性： 是一个方法或一对方法，但在调用它的代码看来，它是一个字段，即属性适合于以字段的方式使用方法调用的场合。
-
字段是存储类要满足其设计所需要的数据，字段是与类相关的变量。
//属性
//声明一个内部字段
private int shoutNum=3;
//get方法表示外界调用时可以得到shoutNum的值
public int getShoutNum() {
return shoutNum;
}
//set方法表示外界可以给内部的shoutNum赋值
public void setShoutNum(int shoutNum) {
this.shoutNum = shoutNum;
}
//类的方法
public String Shout(){
String result="";
for (int i=0;i<shoutNum;i++){
result +="喵";
}
return "我的名字叫" + name + "，我会"+ result;
}
@Test
public void button1_Click(){
Cat cat = new Cat("小黑");
cat.setShoutNum(10);
System.out.println(cat.Shout());
}
修饰符：
- public表示它所修饰的类成员可以允许其他任何类来访问，俗称公有的。
- private表示只允许同一个类中的成员访问，其他类包括它的子类无法访问，俗称私有的。
- 如果在类中的成员没有加修饰符，则被认为是private的。通常字段都是private，即私有的变量，而属性都是public，即公有的变量。
属性：
- get访问器返回与声明的属性相同的数据类型，表示的意思是调用时可以得到内部字段的值或引用
- set访问器没有显式设置参数，但它有一个隐式参数，用关键字value表示，它的作用是调用属性时可以给内部的字段或引用赋值。
变量私有的叫字段，公有的是属性
get方法和set方法快捷键：Alt + Insert
联想电脑：Fn + Alt + Insert
补充：
-
protected：（被保护的）可以修饰成员变量、方法和内部类，它不能用来修饰类，它也不能用来修饰接口、接口的成员变量和接口的方法。被protected修饰的只能被同一包中的类和子类访问。
-
default：（默认的）使用default就相当于不添加控制访问的修饰符，它能修饰类，成员变量和方法。被default修饰的只能被同包下的类所访问。
总结：
| 修饰符 | 同类 | 同包 | 子类 | 不同包 |
|---|---|---|---|---|
| public | √ | √ | √ | √ |
| protected | √ | √ | √ | × |
| default | √ | √ | × | × |
| private | √ | × | × | × |
5，封装
面向对象的三大特性之一——封装
- 每个对象都包含它能进行操作所需要的所有信息，这个特性称为封装，因此对象不必依赖其他对象来完成自己的操作。
注：刚才提炼出Cat类，其实就是在做封装
在写一个Dog类
public class Dog {
private String name="";
public Dog(String name){
this.name = name;
}
public Dog(){
this.name="无名";
}
private int shoutNum=3;
public int getShoutNum() {
return shoutNum;
}
public void setShoutNum(int shoutNum) {
this.shoutNum = shoutNum;
}
public String Shout(){
String result="";
for (int i=0;i<shoutNum;i++){
result +="旺旺";
}
return "我的名字叫" + name + "，我会"+ result;
}
}
@Test
public void button2_Click(){
Dog dog = new Dog("旺财");
dog.setShoutNum(10);
System.out.println(dog.Shout());
}
封装的好处：
- **良好的封装能够减少耦合，**至少我们让Cat和Test的耦合分离了。
- **类内部的实现可以自由地修改，**这也是显而易见的，我们已经对Cat做了很大的改动。
- **类具有清晰的对外接口，**这其实指的就是定义为public的ShoutNum属性和Shout方法。
6，继承
-
对象的继承代表了一种‘is-a’的关系，如果两个对象A和B，可以描述为‘B是A’，则表明B可以继承A。
-
继承者还可以理解为是对被继承者的特殊化，因为它除了具备被继承者的特性外，还具备自己独有的个性。
-
继承定义了类如何相互关联，共享特性。继承的工作方式是，定义父类和子类，或叫做基类和派生类，其中子类继承父类的所有特性。子类不但继承了父类的所有特性，还可以定义新的特性。
子类继承于父类：
- 子类拥有父类非private的属性和功能
- 子类具有自己的属性和功能，即子类可以扩展父类没有的属性和功能
- 子类还可以以自己的方式实现父类的功能（方法重写）
protected表示继承时子类可以对基类有完全访问权
我们会发现Cat类和Dog类大部分代码是相同的，所以我们现在建立一个父类，叫做Animal类。
public class Animal {
protected String name = "";
public Animal(String name) {
this.name = name;
}
public Animal (){
this.name="无名";
}
protected int shoutNum = 3;
public int getShoutNum() {
return shoutNum;
}
public void setShoutNum(int shoutNum) {
this.shoutNum = shoutNum;
}
}
子类从它的父类中继承的成员有方法、域、属性、事件、索引指示器，但对于构造方法，有一些特殊，它不能被继承，只能被调用。对于调用父类的成员，可以用base关键字。”
Cat类：
//继承格式：public class 子类 extends 父类{}
public class Cat extends Animal{
public Cat(String name) {
super(name);
}
public Cat() {
}
public String Shout(){
String result = "";
for (int i=0; i<shoutNum ; i++){
result +="喵,";
}
return "我的名字叫" + name + "，我会"+ result;
}
}
Dog类：
public class Dog extends Animal{
public Dog(String name) {
super(name);
}
public Dog() {
}
public String Shout(){
String result = "";
for (int i=0; i<shoutNum ; i++){
result +="旺,";
}
return "我的名字叫" + name + "，我会"+ result;
}
}
Cat测试类：
@Test
public void button1(){
Cat cat = new Cat();
cat.name="hahah";
//第一种设置叫的次数的方法
//cat.shoutNum=7;
//第二种设置叫的次数的方法
cat.setShoutNum(7);
System.out.println(cat.Shout());
}
Dog测试类相识
继承的优缺点：
- 优点： 继承使得所有子类公共的部分都放在了父类，使得代码得到了共享，这就避免了重复，另外，继承可使得修改或扩展继承而来的实现都较为容易
- 缺点： 那就是父类变，则子类不得不变。另外，继承会破坏包装，父类实现细节暴露给子类，这其实是增大了两个类之间的耦合性。继承显然是一种类与类之间强耦合的关系。
7，多态
面向对象的第三大特性之一——多态
多态表示不同的对象可以执行相同的动作，但要通过它们自己的实现代码来执行
-
子类以父类的身份出现，
-
子类在工作时以自己的方式来实现，
-
子类以父类的身份出现时，子类特有的属性和方法不可以使用
- 为了使子类的实例完全接替来自父类的类成员，父类必须将该成员声明为虚拟的。
- 子类可以选择使用注解@override，将父类实现替换为它自己的实现，这就是方法重写，或者叫做方法覆写。
public String Shout(){
return "";
}
@Override
public String Shout(){
String result = "";
for (int i=0; i<shoutNum ; i++){
result +="喵,";
}
return "我的名字叫" + name + "，我会"+ result;
}
@Test
public void button1(){
Cat cat = new Cat("小黑");
//第一种设置叫的次数的方法
//cat.shoutNum=7;
//第二种设置叫的次数的方法
cat.setShoutNum(7);
System.out.println(cat.Shout());
}
注：
-
不同的对象可以执行相同的动作，但要通过它们自己的实现代码来执行。
-
多态的原理是当方法被调用时，无论对象是否被转换为其父类，都只有位于对象继承链最末端的方法实现会被调用。也就是说，虚方法是按照其运行时类型而非编译时类型进行动态绑定调用的。
8，重构
- 按照前面的思路，如果现在准备加上小牛和小羊，实现牛Cattle和羊Sheep的类，让它们都继承Animal就可以了。如图：
但是猫狗牛羊四个类，除了构造方法之外，还有重复的地方，Shout方法里除了四种动物叫的声音不同外，几乎没有任何差异。
我们可以先把重复的这个Shout的方法体放到Animal类中，
Animal类：
public String Shout(){
String result = "";
for (int i=0; i<shoutNum ; i++){
result += getShoutSound() + ",";
}
return "我的名字叫" + name + "，我会"+ result;
}
protected String getShoutSound(){
return "";
}
此时的子类就极其简单了。除了叫声和构造方法的不同，所有的重复都转移到了父类，真是漂亮之极。
Cat类：
public class Cat extends Animal {
public Cat(String name) {
super(name);
}
public Cat() {
}
@Override
protected String getShoutSound() {
return "喵";
}
}
Dog类：
public class Dog extends Animal {
public Dog(String name) {
super(name);
}
public Dog() {
}
@Override
protected String getShoutSound() {
return "旺";
}
}
Cattle类：
public class Cattle extends Animal {
public Cattle(String name) {
super(name);
}
public Cattle() {
}
@Override
protected String getShoutSound() {
return "哞";
}
}
Sheep类：
public class Sheep extends Animal {
public Sheep(String name) {
super(name);
}
public Sheep() {
}
@Override
protected String getShoutSound() {
return "咩";
}
}
9，抽象类
- 可以考虑把实例化没有任何意义的父类，改成抽象类，同样的，对于Animal类的getShoutSound方法，其实方法体没有任何意义，所以可以用修饰符abstract进行修饰，使之成为抽象方法。
可以把类和方法声明为abstract，即抽象类和抽象方法。
//加abstract关键字，表明是抽象类
public abstract class Animal {
......
//在方法返回值前加abstract表明此方法是抽象方法，抽象方法没有方法体，直接在括号后面加";"
protected abstract String getShoutSound();
}
注意：
- 抽象类不能实例化，刚才就说过，‘动物’实例化是没有意义的；
- 抽象方法是必须被子类重写的方法，不重写的话，它的存在又有什么意义呢？其实抽象方法可以被看成是没有实现体的虚方法；
- 如果类中包含抽象方法，那么类就必须定义为抽象类，不论是否还包含其他一般方法。
我们应该考虑抽象类拥有尽可能多的共同代码，拥有尽可能少的数据
抽象类通常代表一个抽象概念，它提供一个继承的出发点，当设计一个新的抽象类时，一定是用来继承的，所以，在一个以继承关系形成的等级结构里面，树叶节点应当是具体类，而树枝节点均应当是抽象类
10，接口
- 接口（interface）： 是把隐式公共方法和属性组合起来，以封装特定功能的一个集合。一旦类实现了接口，类就可以支持接口所指定的所有属性和成员。声明接口在语法上与声明抽象类完全相同，但不允许提供接口中任何成员的执行方式。
注：
-
实现接口的类就必须要实现接口中的所有方法和属性。
-
一个类可以支持多个接口，多个类也可以支持相同的接口。
-
接口的命名，前面要加一个大写字母‘I’
实例：
- 先创建一个接口，接口用interface声明，而不是class，接口名称前要加‘I’，接口中的方法或属性前面不能有修饰符、方法没有方法体。
public interface IChange {
//声明一IChange接口，此接口有一个方法ChangeThing，参数是一个字符串变量，返回一个字符串。
String ChangeThing(String thing);
}
- 然后我们来创建机器猫的类。
//继承Cat类，实现IChange接口。
//实现接口格式：
//{修饰符} class 类名 extends 父类 implements 接口{}
public class MachineCat extends Cat implements IChange{
public MachineCat(String name) {
super(name);
}
public MachineCat() {
}
//@Override
public String ChangeThing(String thing) {
return Shout() + "我有万能的口袋，我可以变出：" + thing;
}
}
@Test
public void button1(){
MachineCat mcat = new MachineCat("叮当猫");
StoneMonkey wukong = new StoneMonkey("孙悟空");
IChange[] array = new IChange[2];
array[0]=mcat;
array[1]=wukong;
System.out.println(array[0].ChangeThing("各种各样的东西！"));
System.out.println(array[1].ChangeThing("各种各样的东西！"));
}
从表象上来说，抽象类可以给出一些成员的实现，接口却不包含成员的实现，抽象类的抽象成员可被子类部分实现，接口的成员需要实现类完全实现，一个类只能继承一个抽象类，但可实现多个接口等等。
抽象类和接口的区别：
-
类是对对象的抽象；抽象类是对类的抽象；接口是对行为的抽象。
接口是对类的局部（行为）进行的抽象，而抽象类是对类整体（字段、属性、方法）的抽象。如果只关注行为抽象，那么也可以认为接口就是抽象类。总之，不论是接口、抽象类、类甚至对象，都是在不同层次、不同角度进行抽象的结果，它们的共性就是抽象。
-
如果行为跨越不同类的对象，可使用接口；对于一些相似的类对象，用继承抽象类。
比如猫呀狗呀它们其实都是动物，它们之间有很多相似的地方，所以我们应该让它们去继承动物这个抽象类，而飞机、麻雀、超人是完全不相关的类，叮当猫是动漫角色，孙悟空是古代神话人物，这也是不相关的类，但它们又是有共同点的，前三个都会飞，而后两个都会变出东西，所以此时让它们去实现相同的接口来达到我们的设计目的就很合适了。其实实现接口和继承抽象类并不冲突的，完全可以让超人继承人类，再实现飞行接口，超人除了内裤外穿以外，基本就是一个正常人的样子，让他继承人类是对的，但他本事很大，除了飞天，他还具有刀枪不入、力大无穷等等非常人的能力，而这些能力也可能是其他对象具备的，所以就让超人去实现飞行、力大无穷等行为接口，这就可以让超人和飞机比飞行，和大象比力气了，这就是一个类只能继承一个抽象类，却可以实现多个接口的做法。
-
从设计角度讲，抽象类是从子类中发现了公共的东西，泛化出父类，然后子类继承父类，而接口是根本不知子类的存在，方法如何实现还不确认，预先定义。
这里其实说明的是抽象类和接口设计的思维过程。回想一下上面的内容，先是有一个Cat类，然后再有一个Dog类，观察后发现它们有类似之处，于是泛化出Animal类，这也体现了敏捷开发的思想，通过重构改善既有代码的设计。事实上，只有小猫一个类的时候，你就去设计一个动物类，这就可能成为过度设计了。
11，集合
数组的优缺点：
- 优点：比如说数组在内存中连续存储，因此可以快速而容易地从头到尾遍历元素，可以快速修改元素等等。
- 缺点：应该是创建时必须要指定数组变量的大小，还有在两个元素之间添加元素也比较困难。
集合定义：
- 所以现在提供了用于数据存储和检索的专用类，这些类统称集合。这些类提供对堆栈、队列、列表和哈希表的支持。大多数集合类实现相同的接口。我们现在介绍当中最常用的一种，ArrayList。
集合和数组区别：
- 首先ArrayList是命名空间System.Collections下的一部分，它是使用大小可按需动态增加的数组实现IList接口。
- ArrayList的容量是ArrayList可以保存的元素数。ArrayList的默认初始容量为0。随着元素添加到ArrayList中，容量会根据需要通过重新分配自动增加。使用整数索引可以访问此集合中的元素。此集合中的索引从零开始。
@Test
public void button1(){
//声明一集合变量，可以用接口List，也可以直接声明"ArrayList arrayAnimal;"
List arrayAnimal;
//实例化Animal对象，注意，此时并没有指定arrayAnimal的大小，这与数组不同。
arrayAnimal = new ArrayList();
//调用集合arrayAnimal的add方法添加对象，其参数是Object，所以new Cat和new Dog都没问题。
arrayAnimal.add(new Cat("小花"));
arrayAnimal.add(new Cat("小花2"));
arrayAnimal.add(new Dog("小黑"));
arrayAnimal.add(new Dog("小黑2"));
for (Object o : arrayAnimal) {
((Animal)o).setShoutNum(5);
System.out.println(((Animal)o).Shout());
}
}
如果要小花2和小黑，他们在集合中次序应该是1和2（从0开始计算）；
代码：
arrayAnimal.remove(1);
arrayAnimal.remove(1);
有没有疑问？哈哈哈，集合和数组的不同就在于此，当代码执行完（ ‘arrayAnimal.remove(1);’ ）时，小花已经被移除了集合，此时小黑的次序就会变化，变成1。等于整个后序对象都向前移一位了。
集合相较于数组的好处：
- 主要就是它可以根据使用大小按需动态增加，不用受事先设置其大小的控制。还有就是可以随意地添加、插入或移除某一范围元素，比数组要方便。
ArrayList不是类型安全的。还有就是ArrayList对于存放值类型的数据，比如int、string型（string是一种拥有值类型特点的特殊引用类型）或者结构struct的数据，用ArrayList就意味着都需要将值类型装箱为Object对象，使用集合元素时，还需要执行拆箱操作，这就带来了很大的性能损耗。
- **装箱:**就是把值类型打包到Object引用类型的一个实例中。比如整型变量 i 被“装箱”并赋值给对象 o 。
int i = 123;
object o = (object) i; // boxing
- 拆箱: 就是指从对象中提取值类型。此例中对象 o 拆箱并将其赋值给整型变量 i 。
o = 123;
i = (int) o; // unboxing
相对于简单的赋值而言，装箱和拆箱过程需要进行大量的计算。对值类型进行装箱时，必须分配并构造一个全新的对象。其次，拆箱所需的强制转换也需要进行大量的计算
12，泛型
- 泛型 是具有占位符（类型参数）的类、结构、接口和方法，这些占位符是类、结构、接口和方法所存储或使用的一个或多个类型的占位符。泛型集合类可以将类型参数用作它所存储的对象的类型的占位符；类型参数作为其字段的类型和其方法的参数类型出现。
@Test
public void button2(){
/*关键就在这里，声明一泛型集合变量，用接口List。
* 注意：List<Animal>表示此集合变量只能接受Animal类型，其他不可以。
* */
List<Animal> arrayAnimal;
//事例化List对象，注意：此时也需要指定List<T>的'T'的类型是Animal。
arrayAnimal = new ArrayList<Animal>();
arrayAnimal.add(new Cat("小花"));
arrayAnimal.add(new Cat("小花2"));
arrayAnimal.add(new Dog("小黑"));
arrayAnimal.add(new Dog("小黑2"));
for (Object o : arrayAnimal) {
((Animal)o).setShoutNum(5);
System.out.println(((Animal)o).Shout());
}
}
注：
- 其实List和ArrayList在功能上是一样的，不同就在于，它在声明和实例化时都需要指定其内部项的数据或对象类型，这就避免了刚才讲的类型安全问题和装箱拆箱的性能问题了
- 通常情况下，都建议使用泛型集合，因为这样可以获得类型安全的直接优点而不需要从基集合类型派生并实现类型特定的成员。
- 如果集合元素为值类型，泛型集合类型的性能通常优于对应的非泛型集合类型（并优于从非泛型基集合类型派生的类型），因为使用泛型时不必对元素进行装箱。
扫一扫
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
