【大话设计模式】第0章 面向对象基础

第0章 面向对象基础

面向对象编程，英文叫Object-Oriented Programming

1. 类与实例

​ 对象是一个自包含的实体，用一组可识别的特性和行为来标识。
​ 类就是具有相同的属性和功能的对象的抽象的集合。

1.1 一个类的例子

public class Cat{
    
    
    public String shout(){
    
    
        return "瞄"
    }
}

​ 'Cat’ 就是类的名称，'shout’就是类的方法。

(1) 类名称首字母记着要大写。多个单词则各个首字母大写: 【俗称：驼峰形式】
(2) 对外公开的方法需要用 'public’ 修饰符。

1.2 new一个对象

​ 实例化就是创建对象的过程，使用new关键字来创建。

public class Test {
    
    
	public static void main(String[] args){
    
    
        Cat cat = new Cat();
        // 分解动作
        // Cat cat;	//声明一个Cat对象，对象名为cat
        // cat = new Cat(); //将此cat对象实例化
        System.out.printIn(cat.shout());
    }
}

2. 构造方法

​ 构造方法，又叫构造函数进行初始化。构造方法与类同名，无返回值，也不需要void，在new的时候调用。
​ 上面1.2节中 Cat cat = new Cat(); 调用的就是构造方法。（此时注意，类中并没有创建构造方法，但实际情况是：所有类都有构造方法，如果你不编码则系统默认生成空的构造方法，若你有定义的构造方法，那么默认的构造方法就会失效了。 也就是说，由于你没有在Cat类中定义过构造方法，所以Java语言会生成一个空的构造方法Cat()。当然，这个空的方法什么也不做，只是为了让你能顺利地实例化而已。）

public class Cat {
    
    
	//声明Cat的私有字符串变量
    nameprivate String name = "";
    //定义Cat类的构造方法，参数是输入一个字符串
    public Cat(String name){
    
    
        //将参数赋值给私有变量name
        this.name = name;
    }
}
public String shout(){
    
    
    return "我的名字叫" + name +  " 喵";
}

​ （生动形象的例子：小猫咪一生下来就有名字~）
​ 此时，Main.java函数中就需要传入名字的参数了。

public class Test {
	public static void main(String[] args){
        Cat cat = new Cat("咪咪");
        System.out.printIn(cat.shout());
    }
} 

3. 方法重载

​ 方法重载提供了创建同名的多个方法的能力，但这些方法需使用不同的参数类型。

public class Cat {
	private String name = uu:
    public Cat(String name){
        this.name = name;
    }
    //将构造方法重载
    public Cat(){
        this.name="无名";
    }
}
public String shout(){
    return "我的名字叫"+ name + "喵";
}

​ 这样写 Cat cat = new Cat(); 这句话就不会报错了。

【注意】

1. 方法重载不仅仅可以用在构造方法上，还可以用在普通的函数。
2. 两个方法必须要方法名相同，但参数类型或个数必须要有所不同。
3. 方法重载可在不改变原方法的基础上，新增功能。

4. 属性与修饰符

​ 属性是一个方法或一对方法，即属性适合于以字段的方式使用方法调用的场合。字段是存储类要满足其设计所需要的数据，字段是与类相关的变量。(前面的Cat类里面的name就是一个字段，一般都会在数据库里面一一对应。)

public class Cat{
    
    
    //声明一个内部字段，注意是private，默认叫的次数为3
    private int shoutNum = 3;
    //表示外界灯以给内部的shoutnum赋值
    public void setShoutNum(int value){
    
    
        this.shoutNum=value;
    }
    //表示外界调用时可以得到shoutNum的值
    public int getShoutNum(){
    
    
        return this.snoutnum;
    }
}

public	公有的	它所修饰的类成员可以允许其他任何类来访问
private	默认，私有的	只允许同一个类中的成员访问，其他类包括它的子类无法访问。 如果在类中的成员没有加修饰符，则被认为是private的。
protected	保护	继承时子类可以对基类有完全访问权。（用protected修饰的类成员，对子类公开,但不对其他类公开。）

​ get方法：返回与声明的属性相同的数据类型，表示的意思是调用时可以得到内部字段的值或引用；
​ set方法：有一个参数，用关键字value表示，它的作用是调用属性时可以给内部的字段或引用赋值。

（上：去掉set方法，属性只读；下：给set方法加判断条件）

public class Cat {
    
    
	private String name = uu:
    public Cat(String name){
    
    
        this.name = name;
    }
    //将构造方法重载
    public Cat(){
    
    
        this.name="无名";
    }
}
public String shout(){
    
    
    return "我的名字叫"+ name + "喵";
}

调用

Cat cat = new Cat("咪咪");
cat.setShoutNum(5);//给属性赋值
System.out.printIn(cat.shout());

【注意】变量私有的叫字段，公有的是属性。

5. 封装（OO三大特性之一）

​ 每个对象都包含它能进行操作所需要的所有信息，这个特性称为封装，因此对象不必依赖其他对象来完成自己的操作。

作用：
第一，良好的封装能够减少耦合
第二，类内部的实现可以自由地修改
第三，类具有清晰的对外接口（指的就是前面的 ShoutNum 属性和 shout 方法）

这里的封装就相当于前面的Cat类。

6. 继承（OO三大特性之一）

​ 对象的继承代表了一种“is-a’的关系，如果两个对象A和B，可以描述为‘B是A’，则表明B可以继承A。继承者还可以理解为是对被继承者的特殊化，因为它除了具备被继承者的特性外，还具备自己独有的个性。
​ 继承定义了类如何相互关联，共享特性。继承的工作方式是，定义父类和子类，或叫作基类和派生类，其中子类继承父类的所有特性。子类不但继承了父类的所有特性，还可以定义新的特性。

如果子类继承于父类，
第一，子类拥有父类非private的属性和功能;
第二，子类具有自己的属性和功能，即子类可以扩展父类没有的属性和功能;
第三，子类还可以以自己的方式实现父类的功能( 方法重写)。

​ 将猫、狗这些相同类的属性和方法放在一个类里面叫做Animal

public class Animal {
    
    
	protected String name = "";
    public Animal(String name){
    
    
        this.name = name;
    }
    public Animal(){
    
    
        this.name ="无名";
    }
    protected int shoutNum = 3;
    public void setShoutNum(int value){
    
    
        this.shoutNum = value:
    }
    public int getShoutNum(){
    
    
        return this.shoutNum;
    }
    public String shout(){
    
    
        return "";
    }
}

​ 子类从它的父类中继承的成员有方法、属性等，但对于构造方法，有一些特殊，它不能被继承，只能被调用。对于调用父类的成员，可以用base关键字。

public class Cat extends Animal{
    
    
    public Cat(){
    
    
        super();
    }
    public Cat(String name){
    
    
        super(name); // 子类构造方法需要调用与父类同栏数的构造方法，用super关键宇
    }
    public String shout(){
    
    
        String result="";
        for(int i=0;i<this.shoutNum;i++){
    
    
            result +="喵";
        }
        return "我的名字叫"+ name + " " + result;
    }
}

​ 继承的优点是，继承使得所有子类公共的部分都放在了父类，使得代码得到了共享，这就避免了重复，另外，继承可使得修改或扩展继承而来的实现都较为容易。
​ 继承是有缺点的，那就是父类变，则子类不得不变。继承会破坏包装，父类实现的细节暴露给子类，增大了两个类之间的耦合性 （一方的变化都会影响到另一方，继承显然是一种类与类之间强耦合的关系）
​

7. 多态（OO三大特性之一）

​

public class Test {
	public static void main(String[] args){
        //有五个动物报名的资格
        AnimalarravAnimal=new Animal[5];
        //报名代码
        arrayAnimal[0] = new Cat("小花");
        arrayAnimal[1] = new Cat("阿毛");
        arrayAnimal[2] = new Cat("小黑");
        arrayAnimal[3] = new Cat("娇娇");
        arrayAnimal[4] = new Cat("咪咪");
        
        //开始叫声比赛，遍历这个数组，让每个动物对象都shout
        for(int i=0;i<5;i++){
             System.out.println(arrayAnimal[i].shout());
        }
    }
}

​ 多态表示不同的对象可以执行相同的动作，但要通过它们自己的实现代码来执行。

​ 第一，子类以父类的身份出现。
​ 第二，子类在工作时以自己的方式来实现。
​ 第三，子类以父类的身份出现时，子类特有的属性和方法不可以使用。

【在第6点中Cat类里面的shout()方法就是重写的方法。】

​ 多态的原理：当方法被调用时，无论对象是否被转换为其父类，都只有位于对象继承链最末端的方法实现会被调用。也就是说，虚方法是按照其运行时类型而非编译时类型进行动态绑定调用的。【没太懂】
​

8. 重构

​ 看shout方法，这样的设计显然代码重复很大。

此时需要将shout()方法写进到Animal类里面：

public class Animal {
    
    
	protected String name = "";
    public Animal(String name){
    
    
        this.name = name;
    }
    public Animal(){
    
    
        this.name ="无名";
    }
    protected int shoutNum = 3;
    public void setShoutNum(int value){
    
    
        this.shoutNum = value:
    }
    public int getShoutNum(){
    
    
        return this.shoutNum;
    }
    
    //主要改动
    public String shout(){
    
    
        String result="";
        for(int i=0;i<this.shoutNum;i++){
    
    
            result+= getShoutSound() + ", ";
        }
        return "我的名字叫" + name + " " + result;
    }
    
    //注意这里是保护类，仅留给子类去修改
    protected String getShoutSound(){
    
    
        return "";
    }
}

设计其子类就很简单啦~

【注意】子类拥有父类所有非private的属性和方法。

这种设计模式叫做：模板方法！

9. 抽象类

​ 我们完全可以考虑把实例化没有任何意义的父类，改成抽象类。同样地，对于Animal类的getShoutSound方法，其实方法体没有任何意义，所以可以将修饰符改为abstract，使之成为抽象方法。Java允许把类和方法声明为abstract，即抽象类和抽象方法。

public abstract class Animal {
    ...
    //注意这里是保护类，仅留给子类去修改
    protected abstract String getShoutSound();
}

第一，抽象类不能实例化。
第二，抽象方法是必须被子类重写的方法。（抽象方法可以被看成是没有实现体的虚方法）
第三，如果类中包含抽象方法，那么类就必须定义为抽象类，不论是否还包含其他一般方法。

我们应该考虑让抽象类拥有尽可能多的共同代码，拥有尽可能少的数据。

抽象类通常代表一个抽象概念，它提供一个继承的出发点，当设计一个新的抽象类时，一定是用来继承的，所以，在一个以继承关系形成的等级结构里面，树叶节点应当是具体类，而树枝节点均应当是抽象类。

10. 接口

​ 接口是把隐式公共方法和属性组合起来，以封装特定功能的一个集合。一旦类实现了接口，类就可以支持接口所指定的所有属性和成员。声明接口在语法上与声明抽象类完全相同，但不允许提供接口中任何成员的执行方式。
所以接口不能实例化，不能有构造方法和字段;
不能有修饰符，比如public、private等;
不能声明为虚拟的或静态的等。
还有实现接口的类就必须要实现接口中的所有方法和属性。
​ 一个类可以支持多个接口，多个类也可以支持相同的接口。
​ 接口的命名，有些语言前面要加一个大写字母 ‘l’ 。

//声明一个IChange接口
public interface IChange {
    
    
	//此接口有一个方法changeThing,
    //参数是一个字符串变量，返回一字符
    public String changeThing(String thing);
}

​ 实现一个接口

//继承了Cat类，并实现了IChange接口
public class MachineCat extends Cat implements IChange {
    
    
	public MachineCat (){
    
    
        super();
    }
	public MachineCat (String name){
    
    
        super(name);
    }
	//实现了接口的方法
    public String changeThing(String thing){
    
    
        return super.shout()+"，我有万能的口袋，我可变出" + thing;
    }
}

Main.java里面

//创建两个类的实例
MachineCat mcat = new MachineCat("叮唱");
StoneMonkey wukong = new StoneMonkey("孙悟空");
//声明了一个接口数组，将两个类的实例引用给接口数组
IChange[] array = new IChange[2];
array[0] = mcat;
array[1] = wukong;
//利用多态性，实现不同的changeThing
System.out.println(array[0].changeThing("各种各样的东西!"));
System.out.println(array[1].changeThing("各种各样的东西!")):

11. 抽象类和接口的区别！

​ 抽象类可以给出一些成员的实现，接口却不包含成员的实现。
​ 抽象类的抽象成员可被子类部分实现，接口的成员需要实现类完全实现。【不懂】
​ 一个类只能继承一个抽象类，但可实现多个接口等。

​ 第一，类是对对象的抽象，抽象类是对类的抽象，接口是对行为的抽象。
​ 接口是对类的局部(行为)进行的抽象，而抽象类是对类整体(字段、属性、方法)的抽象。如果只关注行为抽象，那么也可以认为接口就是抽象类。总之，不论是接口、抽象类、类甚至对象，都是在不同层次、不同角度进行抽象的结果，它们的共性就是抽象。

第二，如果行为跨越不同类的对象，可使用接口;对于一些相似的类对象，用继承抽象类。
猫呀狗呀它们其实都是动物，它们之间有很多相似的地方，所以我们应该让它们去继承动物这个抽象类，而飞机、麻雀、超人是完全不相关的类，叮哨是动漫角色，孙悟空是古代神话人物，这也是不相关的类，但它们又是有共同点的，前三个都会飞，而后两个都会变出东西，所以此时让它们去实现相同的接口来达到我们的设计目的就很合适了。（实现接口和继承抽象类并不冲突，我完全可以让超人继承人类，再实现飞行接口。一个类只能继承一个抽象类，却可以实现多个接口。）

​ 第三，从设计角度讲，抽象类是从子类中发现了公共的东西，泛化出父类，然后子类继承父类，而接口是根本不知子类的存在，方法如何实现还不确认，预先定义。
​ 抽象类是自底而上抽象出来的，而接口则是自顶向下设计出来的。

​

12. 集合

​ 数组的优点：比如说数组在内存中连续存储，因此可以快速而容易地从头到尾遍历元素，可以快速修改元素等。
​ 缺点：应该是创建时必须要指定数组变量的大小，还有在两个元素之间添加元素也比较困难。

​ Java提供了用于数据存储和检索的专用类，这些类统称集这些类提供对堆栈、队列、列表和哈希表的支持。
​ 大多数集合类实现相同的接口。最常用的是ArrayList。

​ ArrayList是程序包java.util.ArrayList下的一部分，它是使用大小可按需动态增加的数组实现Collection接口。
​ ArrayList的容量是ArrayList可以保存的元素数。ArrayList的默认初始容量为0。随着元素添加到ArrayList中，容量会根据需要通过重新分配自动增加。使用整数索引可以访问此集合中的元素。此集合中的索引从零开始。由于实现了Collection，所以ArrayList 提供添加、插入或移除某一范围元素的方法。

//导入ArrayList所在的程序包import java.util.ArrayList;
public class Test {
    
    
	public static void main(String[] args){
    
    
        //声明集合对象，并实例化对象
        ArrayList arrayAnimal=new ArrayList();
        //调用集合的add方法增加对象，参数是所有对象的抽象类object，
        //所以new Cat()或new Dog()都是可以的
        arrayAnimal.add(new Cat("小花"));
        arrayAnimal.add(new Dog("阿毛"));
        arrayAnimal.add(new Dog("小黑"));
        arrayAnimal.add(new Cat("娇娇"));
        arrayAnimal.add(new Cat("咪咪"));
        
        //删除阿毛、小黑的list
        //集合的变化是影响全局的，它始终都保持元素的连续性
        arrayAnimal.remove(1);
        arrayAnimal.remove(1);
        
        //遍历集合
        for(Object item : arrayAnimal){
    
    
            Animal animal = (Animal)item;//此时需要强制将0bject转换为Animal对象
            System.out.printn(animal.shout());
        }
        
        System.out.println("动物个数:"+arrayAnimal.size());
    }
}

优点：1. 主要就是它可以根据使用大小按需动态增加，不用受事先设置其大小的控制。2. 可以随意地添加、插入或移除某一范围元素，比数组要方便。
缺点：ArrayList不管你是什么对象都是接受的，因为在它眼里所有元素都是Object，这就使得如果你arrayAnimal.add(123)，或者arrayAnimal.add(”HelloWorld”)；在编译时都是没有问题的，但在执行时，for(Animal item:arrayAnimal) 需要明确集合中的元素是Animal类型，而123是整型，HelloWorld是字符串型，这就会在运行到此处时报错，显然，这是典型的类型不匹配错误。

也就是说，ArrayList不是类型安全的。ArrayList就意味着都需要将值类型装箱为Obiect对象，使用集合元素时，还需要执行拆箱操作，这就带来了很大的性能损耗。

**装箱：**就是把值类型打包到Obiect引用类型的一个实例中。
**拆箱：**就是指从对象中提取值类型。

相对于简单的赋值而言，装箱和拆箱过程需要进行大量的计算。对值类型进行装箱时，必须分配并构造一个全新的对象。其次，拆箱所需的强制转换也需要进行大量的计算。装箱拆箱是耗资源和时间的，而ArrayList集合在使用值类型数据时其实就是在不断地做装箱和拆箱的工作，这显然是非常糟糕的事情。 解决办法：泛型。

12. 泛型

​ 泛型是具有占位符( 类型参数 )的类、结构、接口和方法，这些占位符是类、结构、接口和方法所存储或使用的一个或多个类型的占位符。泛型集合类可以将类型参数用作它所存储的对象的类型的占位符，类型参数作为其字段的类型和其方法的参数类型出现。

​ 有ArrayList 类的泛型等效类，该类使用大小可按需动态增加的数组实现Gollection泛型接“T’就是你需要指定的集合口。其实用法上关键就是在ArrayList后面加 ‘’ ，这个 ‘’ 就是你需要指定的集合的数据或对象类型。

import java.util.ArrayList;

public class Test {
    
    
	public static void main(String[] args){
    
    
        //声明泛型集合变量，在<>中声明Animal，意味着此集合只接受Animal对象
        ArrayList<Animal> arrayAnimal=new ArrayList<Animal>();

        arrayAnimal.add(new Cat("小花"));
        arrayAnimal.add(new Dog("阿毛"));
        arrayAnimal.add(new Dog("小黑"));
        arrayAnimal.add(new Cat("娇娇"));
        arrayAnimal.add(new Cat("咪咪"));
        
        //此时循环可以直接明确集合中都是Animal的item
        for(Animal item : arrayAnimal){
    
    
            System.out.printn(item.shout());
        }
        
        System.out.println("动物个数:"+arrayAnimal.size());
    }
}

此时，如果你再写arrayAnimal.add(123);或者arrayAnimal.add(“HelloWorld”); 结果将是编译报错。

ArrayList和ArrayList的区别：
它在声明和实例化时都需要指定其内部项的数据或对象类型，这就避免了类型安全问题和装箱拆箱的性能问题了。

​ 通常情况下，都建议使用泛型集合，因为这样可以获得类型安全的直接优点而不需要从基集合类型派生并实现类型特定的成员。此外，如果集合元素为值类型，泛型集合类型的性能通常优于对应的非泛型集合类型(并优于从非泛型基集合类型派生的类型)，因为使用泛型时不必对元素进行装箱。