JAVA学习面向对象之 扑克牌(初)

感想:

一开始不了解或者说是对JAVA的特性不熟悉,不知道类与类之间的联系,对JAVA的封装,继承,多态不熟悉和没有更好的理解,在以后的学习过程中要掌握并熟悉JAVA的开发习惯,

在写代码过程中还有众多东西没有掌握,靠着老师和同学的帮助完成这次学习,初步了解了JAVA面向对象开发的基本要领。写这个博客以便于自己今后学习,也算是一段美好的回忆吧!

上面是一个类图  表示着写这个程序的只要思路。

Card类:他的下级是cardview上级是player,有着一定的关系

package com.cqvie;
public class Card
{
  public int rank,suit;
  public int cardIdx;
  public CardView cardView;
  public Player owner;
  public boolean selected=false;
  public static String suits[]
                             =new String[]{"","♠","♥","♣","♦"};
  public static String ranks[]
                             =new String[]{"J","Q","K","A","2","小王","大王"};
 
  public Card(int rank,int suit)
  {
    this.rank=rank;  this.suit=suit;
    this.cardView=new CardView(this); //在产生Card对象时,要同步产生CardView对象
  }
  public String toString()
  {
   if(rank<=10) //10点或以下
    return suits[suit]+rank;
   else //10点以上
    return suits[suit]+ ranks[rank-11];
  }
}

CardView类:

package com.cqvie;

import java.awt.Font;
import java.awt.Insets;
import java.awt.Panel;
import java.awt.event.MouseAdapter;
import java.awt.event.MouseEvent;

import javax.swing.JButton;
import javax.swing.JFrame;

public class CardView {
 private Card card; // 关联的Card
 private JButton btn;
 //private static JFrame win; // 依附的窗口
 
 public Card getCard() {
  return card;
 }

public void setCard(Card card) {
  this.card = card;
 }

public JButton getBtn() {
  return btn;
 }

public void setBtn(JButton btn) {
  this.btn = btn;
 }

public CardView(final Card card) {
  this.card = card;
  btn = new JButton();
  btn.setSize(50, 80);
  btn.setMargin(new Insets(0, 0, 0, 0)); //文字和控件的边距
  btn.setFont(new Font(btn.getFont().getName(), Font.BOLD, 16)); //字体设置
  btn.addMouseListener(new MouseAdapter() {

@Override
   public void mouseClicked(MouseEvent e) {
    System.out.println(card.toString());
    card.selected=!card.selected;
    JButton b=(JButton)e.getSource();
    if(card.selected) b.setLocation(b.getX(),b.getY()-20);
    else b.setLocation(b.getX(),b.getY()+20);
   }
   
  });
 }

public void show()
 {
  btn.setText(card.toString());
  int x=card.cardIdx*btn.getWidth()+50;
  //y=card.owner.payerIdx*150+50;
  btn.setLocation(x,20);
  this.card.owner.playerView.panel.add(btn);
 }
 
 public void refresh() //刷新按钮位置
 {
  int x=card.cardIdx*btn.getWidth()+50;
  btn.setLocation(x,20);  
 }
}

Player类:

package com.cqvie;

import java.util.Collections;
import java.util.Comparator;
import java.util.LinkedList;
import java.util.List;

public class Player {
 //public String id;
 public int payerIdx;
 public boolean isLandlord;
 public List<Card> cards;
 public PlayerView playerView;
 public Player(int payerIdx)
 {
  this.payerIdx=payerIdx;
  isLandlord=false;
  cards=new LinkedList<Card>();
  this.playerView=new PlayerView(this);
 }
 
 public void putCards() //出牌
 {
  for(int i=cards.size()-1;i>=0;i--)
   if(cards.get(i).selected)
   {
    //从cards集合中删除card对象
    Card c= cards.remove(i);
    this.playerView.panel.remove(c.cardView.getBtn());
    //c.cardView.getBtn().setVisible(false);
   }
  //出牌后调整按钮位置
  for(int i=0;i<cards.size();i++) //更新cardIdx
  {
   cards.get(i).cardIdx=i;
   cards.get(i).cardView.refresh();
  }
  this.playerView.panel.repaint(); //刷新面板
 } 
 
 public void sortCards() //排序
 {
  Collections.sort(cards,new CardComparetor());
  for(int i=0;i<cards.size();i++) //更新cardIdx
   cards.get(i).cardIdx=i;
 }
}

class CardComparetor implements Comparator<Card>
{
 @Override
 public int compare(Card o1, Card o2) {
  if(o1.rank!=o2.rank) return o2.rank-o1.rank;
  else return o1.suit-o2.suit;
 } 
}

PlayerView类:

package com.cqvie;

import java.awt.Color;
import java.awt.event.MouseAdapter;
import java.awt.event.MouseEvent;

import javax.swing.JButton;
import javax.swing.JFrame;
import javax.swing.JLabel;
import javax.swing.JPanel;

public class PlayerView {
 public Player player;
 public JPanel panel;
 
 public PlayerView(Player p)
 {
  this.player=p;
  panel=new JPanel();
  panel.setLayout(null); //绝对布局
  panel.setSize(1300, 160);
  panel.setBackground(new Color(255, 255, 0));
 }
 
 public void show()
 {
  panel.setLocation(50, (panel.getHeight()+5)*player.payerIdx);
  GameManager.win.add(panel);
  for(int i=0;i<this.player.cards.size();i++)
   this.player.cards.get(i).cardView.show();
  //显示玩家信息
  JLabel label=new JLabel();
  label.setSize(100,50);
  label.setLocation(50, 100);
  label.setText("玩家"+(this.player.payerIdx+1));
  panel.add(label);
  //添加“出牌”按钮
  JButton b=new JButton();
  b.setSize(80,40);
  b.setLocation(150, 120);
  b.setText("出牌");
  panel.add(b);
  b.addMouseListener(
    new MouseAdapter() {

@Override
     public void mouseClicked(MouseEvent e) {
      player.putCards(); //player是外部类的属性
     }
     
    });
 }
}

GameManager类:

package com.cqvie;

import java.util.LinkedList;
import java.util.List;
import java.util.Random;

import javax.swing.JFrame;

public class GameManager {
 public static JFrame win; //所属的窗口(公用)
 public Player[] players=null; //玩家集合
 public GameManager()
 {
  win=new MyWindow();
  players=new Player[3];
  for(int i=0;i<players.length;i++)
   players[i]=new Player(i);
 }
 public void startGame()
 {
  List<Card> cards=new LinkedList<Card>(); //扑克牌
  for(int i=3;i<=15;i++)
   for(int j=1;j<=4;j++)
    cards.add(new Card(i,j));
  
  cards.add(new Card(16,0));
  cards.add(new Card(17,0));
  
  Random r=new Random(); //随机数产生器
  for(int i=0;i<players.length;i++)
  {
   for(int j=0;j<17;j++)
   {
    int k=r.nextInt(cards.size());
    cards.get(k).owner=players[i];
    cards.get(k).cardIdx=j;
    players[i].cards.add(cards.get(k));
    cards.remove(k);
   }
   players[i].sortCards();
  }
  
     int t = (int)(Math.random() *players.length);
  players[t].isLandlord=true; 
  if(players[t].isLandlord)
    for(int m=17;m<=19;m++){
             int k = (int)(Math.random() * cards.size());
             cards.get(k).owner=players[t];
             cards.get(k).cardIdx=m;
             players[t].cards.add(cards.get(k));
             cards.remove(k);
   }
  players[t].sortCards();
  
//  for(int i=0;i<players.length;i++)
//  {
//   System.out.print(players[i].id+players[i].isLandlord+"的牌是");
//   players[i].cards.print();
//   System.out.print("\n------------------------\n");
//  }
 }
 
 public void show()
 {
//  for(int i=0;i<players.length;i++)
//   for(int j=0;j<players[i].cards.size();j++)
//   {
//    players[i].cards.get(j).cardView.show();
//   }
  for(int i=0;i<players.length;i++)
   players[i].playerView.show();
  win.setVisible(true);
 }
}

窗口(win)类:

package com.cqvie;

import javax.swing.*;

public class MyWindow extends JFrame {
 public MyWindow() {
  this.setSize(1500, 800);
  this.setLayout(null);
  this.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
 }

}

Test类:

package com.cqvie;

public class Test {

public static void main(String[] args) {

GameManager gm=new GameManager();
  gm.startGame();
  gm.show();
  
 }

}

时间: 2024-11-05 06:13:07

JAVA学习面向对象之 扑克牌(初)的相关文章

好程序员Java学习路线分享JDBC初体验

好程序员Java学习路线分享JDBC初体验,JDBC(Java DataBase Connectivity,java数据库连接)是一种用于执行SQL语句的Java API,可以为多种关系数据库提供统一访问,它由一组用Java语言编写的类和接口组成.JDBC提供了一种基准,据此可以构建更高级的工具和接口,使数据库开发人员能够编写数据库应用程序 -?Java 具有坚固.安全.易于使用.易于理解和可从网络上自动下载等特性,是编写数据库应用程序的杰出语言.所需要的只是 Java应用程序与各种不同数据库之

JAVA学习--面向对象的特征三:多态性

* 面向对象的特征三:多态性  * 1.多态性指的是什么?多态性,可以理解为一个事物的多种表型形态.  *   1)方法的重载与重写  2)子类对象的多态性  *  * 2.子类对象的多态性使用的前提:①要有类的继承②要有子类对父类方法的重写  *  * 3.程序运行分为编译状态和运行状态.  *   对于多态性来说,编译时,"看左边",将此引用变量理解为父类的类型  *   运行时,"看右边",关注于真正对象的实体:子类的对象.那么执行的方法就是子类重写的.  *

JAVA学习--面向对象的特征二:继承性

* 一.面向对象的特征二:继承性 * 1.为什么要设计继承性?  *  * 2.通过"class A extends B"类实现类的继承.  *   子类:A  父类(或基类 SuperClass):B  *     * 3.子类继承父类以后,父类中声明的属性.方法,子类就可以获取到.  *    明确:当父类中有私有的属性或方法时,子类同样可以获取得到,只是由于封装性的设计,使得子类不可以直接  *        调用罢了.  *   子类除了通过继承,获取父类的结构之外,还可以定义

JAVA学习--面向对象思想的落地法则

* 面向对象思想的落地法则一:  * 1.设计类,并设计类的成员(成员变量&成员方法)  * 2.通过类,来创建类的对象(也称作类的实例化)  * 3.通过“对象.属性” 或“对象.方法”来调用,完成相应的功能  *  * 二.创建的多个对象,彼此各自拥有一套类的属性.当对其中一个对象的属性进行修改时,  * 不会影响到其他对象的属性值.  *  * 三.类的属性(成员变量)  *   成员变量 vs 局部变量  *   相同点:1.遵循变量声明的格式: 数据类型 变量名 = 初始化值  * 

[Java学习]面向对象-package;内部类;UML图表示六种关系

package 软件包 类名前加入命名空间(包),解决命名冲突问题. 定义格式:公司域名倒叙.项目名.模块名; package语句写在文件第一行 使用import语句导入package java.lang; 软件包下的所有类系统自动导入. 编译 javac -d 生成路径 java源文件路径 运行 java 完整类名 内部类 基本 定义:类里面的类. 好处:内部类可以访问其外部类的私有数据. 分为 :静态内部类,成员内部类,局部内部类,匿名内部类 静态内部类 调用静态内部类的静态方法: Oute

Java学习轨迹【面向对象】(持续更新)

其中部分内容为其他博主所作,侵删 6月12日-7月每日更新 Java学习轨迹 一.面向对象 类和对象 1. new关键字所完成的事情 1)为对象开辟了新的内存空间 2)调用类的构造方法 3)返回生成对象的地址 Dog dog=new Dog(); dog是引用,new Dog()生成了一个Dog对象,引用dog指向所生成对象的地址 2.构造方法 1)构造方法必须与类名相同 2)构造方法没有返回值[且不能使用void作返回值] 3)如果在定义类的时候没有为类声明构造方法java编译器会自动为类添加

Java学习笔记&lt;3&gt;面向对象相关

面向对象的基本思想 从现实世界客观存在的事务出发来构造软件系统,并在系统的构造中尽可能运用人类的自然思维方式,如抽象.分类 继承.聚合.多态等. 类和对象的关系 对象中存储了类规定的数据类型,并且对象可以调用类的方法. java面向对象 <1>对象是java程序的核心,一切皆对象. <2>对象可以看成静态属性(成员变量)和动态属性(方法)的封装体. <3>类是创新同一类型对象的模版,定义了该类型对象应具有的成员变量及方法. 类的定义 成员变量可以用java语言的任何一种

java学习中,面向对象的三大特性:封装、继承、多态 以及 super关键字和方法的重写(java 学习中的小记录)

java学习中,面向对象的三大特性:封装.继承.多态 以及 super关键字和方法的重写(java 学习中的小记录) 作者:王可利(Star·星星) 封装     权限修饰符:public 公共的,private 私有的     封装的步骤:          1.使用private 修饰需要封装的成员变量.          2.提供一个公开的方法设置或者访问私有的属性              设置 通过set方法,命名格式:     set属性名();  属性的首字母要大写 访问 通过ge

Java学习总结(三)——面向对象(上)

Java学习总结(三) -面向对象(上) 一.面向对象的概念及思考方式 面向对象的理解:是一种编程思想,他将对象作为解决问题的基本元素,利用对象与对象之间的相互作用来设计程序. 2.面向对象的思考方式:(1)首先确定问题域中的对象 (2)确定对象的特征与功能 (3)了解对象与对象之间的关系 例:设计一个五子棋游戏的对象:·黑白双方对象     ·绘制棋盘     ·输赢规则 二.类与对象 1.对象:用来描述客观事物的一个实体,由一组属性和行为构成. 2.类:(1)是一个模板,他描述一类对象的行为