1.收获
今天讲的知识点虽然只有两个，但是这两个个知识点在我们后面写代码的过程种会起很大的作用，这两个知识点在前天的课上虽然讲过，但是前天的课上我什么也没有听懂，尽管自己下来后进行看视频理解，但是还是没有理解单例设计模式和泛型，直到今天上课讲了之后并且及时的应用，我才理解这个单例设计模式，今天又掌握了新的知识，尽管很少，但是我相信雨点能够聚成河流。这个扑克游戏在后面的部分我有一些地方没有理解，所以这次没有写上来，只将前面理解的部分写上来，等我把后面的理解了在写上来。
2.技术
（1）单例设计模式的两种方式
（2）泛型的应用
（3）扑克游戏（前面部分）
3.技术的实际应用
（1）单例设计模式
单例设计模式有两种一种是懒汉式，另一种是饿汉式，这两种方式有区别，又有相似之处
什么时候要用单例设计模式：当你想在一个类里面访问另一个类的属性或方法，而你又想在另一个类里面访问这个类的属性或方法，并且一次访问对这个类的影响或结果对另一次有影响，这个时候就可以采用单例设计模式。
A.饿汉式
//饿汉式
class Poker{
//defaut,sharedInstance,manager
//2.定义一个静态的成员变量 记录这个单例对象
public static final Poker shared=new Poker();
//1.默认构造方法私有化
private Poker(){
}
public void test(){
}
}
在访问时就不需要创建一个新的对象，直接访问
Poker.shared.test();
B.懒汉式
//懒汉式
class Player{
public int count;
//2.创建一个静态的变量
private static Player shared=null;
//1.私有化构造方法
private Player(){
}
//3.提供外部访问的方法
public static Player getInstance(){
Object b=new Object();
synchronized (b) {
if (shared == null) {
//如果没有 就创建一个
shared = new Player();
}
}
return shared;
}
}
在访问时就不需要创建一个新的对象，直接访问
Poker.shared.test();
这两者的区别就是懒汉式就是在你需要的时候在创建，而饿汉式时不管你需不需要就先创建起，在执行的安全行上，饿汉式安全一点。
（2）泛型的应用
什么时候要用泛型：当你想要存的全是引用类型的数据的时候，但是数组无法满足需求。
泛型：
class Test2{
public static void main(String[] args){
//泛型
/**
* 数组里面保存的都是对象的引用（指针）
* 改变数组里面的对象的属性变量
* 原始对象的值也跟着改变
* 因为大家指向的是同一块内存空间
*/
ArrayList people=new ArrayList<>();
//添加数据
Person xw=new Person();
people.add(xw);
Person zs=new Person();
people.add(zs);
//访问数据
Person xw2=people.get(0);
xw2.name="小王";
System.out.println(xw.name);
}
}
class Person{
public String name;
}
效果
在这里为什么是“小王”，是因为xw和xw2他们指向是同一个地方，当其中一个去改变他所指的东西，而另一个指向的内容也随之改变。
（3）扑克游戏（前面部分）
首先就是对这个游戏进行构思，到底怎么去做，分为哪几个部分，开从哪入手，需要哪些变量，这些构造需要在开始制作一下，不需要多么细，要个大楷就可以，这样有利于在后面写的过程中有好的思路。
接下来就按照这个思路来写。
首先想到是在这个项目中有许多的输出语句，我们就用一个类来管理
//输入输出语句
public class tools {
//如果不需要保持数据 没有成员变量
//提供静态方法 访问方便
public static void showText(boolean hasStar,boolean hasln,String...text){
//System.out.print(hasStar?"****************\n":"");
if(hasStar==true){
System.out.print("****************\n");
}
if(text.length==1){
//有分隔符的时候就换行
System.out.print(text[0]+(hasStar?"\n":""));
}else{
//输出带编号的多行数据
for(int i=1;i<=text.length;i++){
System.out.println(i+". "+text[i-1]);
}
}
if(hasStar==true){
System.out.print("****************\n");
}
//判断是否换行
System.out.print(hasln?"\n":"");
}
然后再想到是我们需要一副牌，但是也是由一张张牌组成的，那么我们就需要创建管理一张牌的类和一户牌的类，但是在一张牌上是由两个属性的，这时我们需要用一个类来管理牌的类型
一张牌类：
public class Poker {
private String dot;
private PokerType type;
public Poker(String dot,PokerType type){
this.dot=dot;
this.type=type;
}
//setter/getter方法
public void setDot(String dot){
this.dot=dot;
}
public String getDot(){
return dot;
}
public PokerType getType() {
return type;
}
public void setType(PokerType type) {
this.type = type;
}
}
牌的类型：
public class PokerType {
private String pic;
private int id;
public PokerType(String pic,int id){
this.id=id;
this.pic=pic;
}
public String getPic() {
return pic;
}
public int getId() {
return id;
}
public void setPic(String pic) {
this.pic = pic;
}
public void setId(int id) {
this.id = id;
}
}
然后是一副牌：
public class PokerManager {
}
首先我们需要产生一副牌而一副牌是由四种不同的花色的牌组成的，而一副牌是固定的，就是将其常量化，就创建一个管理常量的类来保存常量，这里有牌的数字和花色
public class constant {
//有数组保存牌的点数
public static final String[] DOTS={"2","3","4","5","6","7","8","9","10","J","Q","K","A"};
//保存固定的几个花色
public static final PokerType[] TYPES={PokerType.SPADES,PokerType.HEARTS,PokerType.CLUBS,PokerType.DIAMANDS};
}
然后就来利用这些常量来生成一副牌在牌的管理器里面
//保存一副牌
private ArrayList pokers=new ArrayList<>();
//提供一个方法生产一副牌
public void propokers(){
//遍历整个点数
for(int i=0;i 接下来就需要一个方法来展示这一副牌，也是在牌的管理器里面
//显示所有的牌
public void showPokers(){
for(Poker poker:pokers){
System.out.print(poker.getDot()+poker.getType().getPic()+" ");
}
System.out.println();
}
现在牌有了，就需要人来玩，而玩家就需要一个类来管理玩家，而每个玩家也有自己的属性，那么玩家也就需要一个类来管理
每个玩家：
public class Player {
public String name;
public int id;
public int money;
public Player(){
}
//有参的构造方法
public Player(String name,int id,int money){
this.id=id;
this.money=money;
this.name=name;
}
管理玩家：
public class PlayerManager {}
现在需要的是玩家，以及需要几个玩家，
首先创建玩家的基本信息，也是常量类
//保存默认的玩家信息
public static final String[] DEFUALT_NAMES={"刘德华","张家辉","周润发","周星驰","赌王","赌圣","赌侠"};
生成所需要的玩家
//保存所有的玩家
ArrayList players=new ArrayList<>();
//初始化玩家
public void initPlayer(int count){
for(int i=0;i 现在需要显示玩家的信息，用一个函数来显示，在玩家管理器里面
/输出玩家信息
public void showPlayers(){
for(Player player:players){
System.out.println(player);
}
}
现在玩家有了，牌有了，就来开搞游戏的开始界面，就调用前面的输入函数
// 欢迎界面
tools.showText(true,false,new String[]{"欢迎来到扑克游戏！"});
输出整副牌，就调用输出牌的函数，但是需要创建一个对象，但是又不想创建一个对象，此时就想到了用单例设计模式。
首先要在函数所在类进行操作
//2.创建静态变量
public static final PokerManager manager=new PokerManager();
//1.私有化构造方法
private PokerManager(){};
这样就可以直接访问了
PokerManager.manager.propokers();
PokerManager.manager.showPokers();
现在需要提示输入游戏的玩家人数，然后把这些玩家的信息数出，在输出时也要创建一个一个对象，但是又不想创建一个对象，就要用单例设计模式，在接收玩家人数时由于是一个常量，我们就可以写一个函数在常量类里面
//接收用户输入
public static int getInput(){
Scanner scanner=new Scanner(System.in);
return scanner.nextInt();
}
然后进行输出玩家信息
//提示输入玩家人数
tools.showText(false,false,"请输入参与人数：");
int count=tools.getInput();
PlayerManager.playerManager.initPlayer(count);
接下来就是游戏的正式开始，但是此时需要一个来管理整个游戏过程中的操作，于是就创建了一个GameCenter类，并在里面写入提醒游戏开始的的函数
public void start(){
System.out.println("游戏开始，请打底");
//底注
PlayerManager.playerManager.betAll(constant.BASE);
PlayerManager.playerManager.showPlayers();
}
后面的内容由于没理解，所以没能够将其写完，但是我会去理解的，并且会来把他写上的。