day5

面向对象的特征

1.封装
2.继承
3.多态

1.封装

封装概述：是指隐藏对象的属性和实现细节，仅对外提供公共public访问方式。
封装好处：隐藏实现细节，提供公共的访问方式。提高代码的复用性和安全性。
封装原则：封装原则将不需要对外提供的内容都隐藏起来。把属性隐藏，提供公共方法对其访问。

2.继承，子父类关系

继承：让类与类之间产生关系，子父类关系
案例演示：动物类，猫类，狗类。定义两个属性（颜色，腿的个数）两个功能（吃饭，睡觉）。extends是继承的意思。Animal是父类。Cat和Dog都是子类。
使用继承前使用继承后的一个简单区别就是代码简化了。
继承的好处：1.提高了代码的复用性。2.提高了代码的维护性。3.让类与类之间产生了关系，继承是多态的前提。
继承的弊端：1.类的耦合性增强了。2.开发的原则：高内聚，低耦合。耦合：类与类的关系。内聚：就是自己完成某件事情的能力。
Java类的继承特点：java只支持单继承，不支持多继承。（一个儿子只能有一个爹）。有些语言是支持多继承，多继承的格式：extends类1，类2，…。java支持多层继承（继承体系）如果想用这个体系的所有功能用最底层的类创建对象。如果想看这个体系的共性功能，看对顶层的类

方法重写概述及其应用
什么是方法重写：方法重写是指子父类出现了一模一样的方法。重写这个概念只是存在子类和父类中。
方法重写的应用：当子类需要父类的功能，而子类有自己特有内容时，可以重写父类中的方法。这样，即沿袭了父类的功能，又定义了子类特有的内容。

3.多态

什么是多态：多态就是事物存在的多种形态
java中存在多态的前提条件：要有继承关系，要有方法重写，要有父类引用指向子类对象。
多态中向上转型和向下转型
向上转型：父类指向子类对象Person p=new SuperMan（）；
向下转型：子类指向父类对象SuperMan sm=（SuperMan）p；
**向下转型注意：父类的真实对象必须是子类对象，否则会有问题。
**
斗地主案例
以下为代码：
package com.zhongruan;

import java.util.ArrayList;
import java.util.Collections;
import java.util.HashMap;

public class Test3 {
public static void main(String[] args) {
ArrayList col = new ArrayList();
col.add(“♠”);
col.add(“♥”);
col.add(“♦”);
col.add(“♣”);
ArrayList num = new ArrayList();
num.add(“3”);
num.add(“4”);
num.add(“5”);
num.add(“6”);
num.add(“7”);
num.add(“8”);
num.add(“9”);
num.add(“10”);
num.add(“J”);
num.add(“Q”);
num.add(“K”);
num.add(“A”);
num.add(“2”);
HashMap<Integer, String> map = new HashMap<Integer, String>();

    int a = 0;
    for (String b : num) {
        for (String c : col) {
            map.put(a++, b+c);
        }
    }
    map.put(a++, "小王");
    map.put(a++, "大王");
    ArrayList<Integer> pd = new ArrayList<Integer>();

    for (int i = 0; i <= 53; i++) {
        pd.add(i);
    }
    Collections.shuffle(pd);


    ArrayList<Integer> id1 = new ArrayList<Integer>();
    ArrayList<Integer> id2 = new ArrayList<Integer>();
    ArrayList<Integer> id3 = new ArrayList<Integer>();
    ArrayList<Integer> id4 = new ArrayList<Integer>();

    for (int i = 0; i < pd.size(); i++) {
        if(i>=51) {
            id4.add(pd.get(i));
        } else {
            if(i%3==0) {
                id1.add(pd.get(i));
            }else if(i%3==1) {
                id2.add(pd.get(i));
            }else {
                id3.add(pd.get(i));
            }
        }
    }

    Collections.sort(id1);
    Collections.sort(id2);
    Collections.sort(id3);

    ArrayList<String> o = new ArrayList<String>();
    ArrayList<String> t = new ArrayList<String>();
    ArrayList<String> th = new ArrayList<String>();
    ArrayList<String> f = new ArrayList<String>();

    for (Integer x : id1) {
        o.add(map.get(x));
    }
    for (Integer x : id2) {
        t.add(map.get(x));
    }
    for (Integer x : id3) {
        th.add(map.get(x));
    }
    for (Integer x : id4) {
        f.add(map.get(x));
    }

    System.out.println("ID1"+o);
    System.out.println("ID2"+t);
    System.out.println("ID3"+th);
    System.out.println("底牌"+f);
}

}
运行结果为：

注：Collections.sort（）运用：类似于洗牌，将顺序打乱