JAVA学习面向对象之扑克牌（初）

Posted 2020-07-24

tags:

篇首语：本文由小常识网(cha138.com)小编为大家整理，主要介绍了JAVA学习面向对象之扑克牌（初）相关的知识，希望对你有一定的参考价值。

2016年4月26号正式步入JAVA学习课堂，学习了第一节JAVA课程，由于以前有C语言基础，所以课程有点快！

第一天：学习了教材的第一部分，第一部分总共两章，分别是JAVA简介和JAVA基础语法。

JAVA中字符用unicode编码，以前学的C是用ASCLL编码的，unicode编码完全包含ASCLL编码，并且还有很多事在ascll中没有的；
JAVA中每一个小数常量默认为double型；
数据的转型操作中，自动转换就是将范围小的数据类型自动变为范围大的数据类型，强制转型是将范围大的数据类型转变为范围小的数据类型，转换方式有两种：数字F和（float)数字；
JAVA中有一种数据类型叫布尔型（boolean),并且在JAVA中关系表达式的数据类型必须是boolean型。语句 int x=1>2在C语言中是对的，结果是x=0,而在JAVA中就是错的，因为1>2在JAVA中的数据类型是布尔型，x是整型，不能把结果为布尔型的结果赋值给整型。注：if语句内必须是布尔型。

第二天：初步学习类与对象的概念，听得恍恍惚惚！

第三天：继续学习类与对象

声明并实例化对象有两种格式：

　　　　格式一, 对象名称 =new 类名称（）；

　　　　例如：Person per = new Person（）；

　　　　格式二，分步完成

　　　　声明对象类名称对象名称 = null ;

　　　　实例化对象对象名称 = new 类名称（）；

　　　　例如：

Person per =null;

per = new Person（）；

　　　2.定义一个类

　　　　Package 包名

　　　　Public class 类名

　　　　{

　　　　成员变量； //属性（名词，表特征）

　　　　构造方法；

　　　　成员函数；//方法（动词，表示行为）

　　　　}

　　　　属性和方法统称为类成员（member）。

　　　3.Java中指针占4个字节（java指针，什么鬼？），当一个对象没有任何指针指向它时，将会被系统回收，虽然Java本身提供了自动垃圾收集机制，但是在代码编写中，如果产生了过多的垃圾，则对于程序的性能也会带来影响，所以在开发人员编写代码的过程中应该尽量减少无用对象的产生，回避垃圾。

　　　4.然后讲了几个例子，对java封装一个初步的学习。

　　　　成员变量名的第一个单词字母必须小写，后续单词的首字母大写。比如：userName，age,password,birthday等；

　　　　成员变量对应的getter（setter)写法必须以get(set)开头，后续单词的首字母大写，比如：getUerName(setUerName),getPassword(setPassword),getAge(setAge)等。

第四天：学习构造方法，this关键字，匿名对象等

　　　1.构造方法

　　　　a.构造方法的名称和类名称保持一致；

　　　　b.构造方法不允许由返回值类型声明；（没有return语句）

　　　　c.一个类之中至少存在一个构造方法。

　　默认情况下会存在一个无参的构造方法。

　　class Person{ //类名称首字母大写

　　　　public Person(){ //无参返回值的方法

　　　　　　 }

　　 2.this关键字

　　　　a.“this.属性”表示本类属性；

　　　　b.书上建议：日后的所有开发中，为了避免不必要的bug出现，只要是调用类中属性的情况，都要使用“this.属性"的方式进行表示；

　　　　c.(this)调用本类方法

　　　　　　所有的构造方法是在对象实例化时被默认调用的，而且是在调用普通方之前调用用，所以使用”this（）“调用构造方法的操作一定要放在构造方法的首行。

　　 3.声明并开辟数组（也可以称为实例化数组）　　

　　　　　　　数据类型数组名称 []=new 数据类型 [长度]; int a[] =new int[3];

　　　　　　　数据类型 [] 数组名称 =new 数据类型 [长度]； int [] a=new int [3];

第五天：二维数组

　　　1.动态初始化

　　　　数据类型数组名称 [][]=new 数据类型[行数][列数] ;

　　　　如，int a[][]=new int[7][8];

　　　2.静态初始化

　　　　数据类型数组名称 [][]=new 数据类型 [][]{{值，值，...},{值，值，...},...};

　　　　如，int a[][]=new int[][]{{1,2,3},{54,6},{8,9,10,16}};

　　　3.对于数组data[][],

　　　　data.length 行数

　　　　data[i].length 列数（即i行的列数）

　　　　在java中，每一行的列数可以不同（锯齿状数组）

第六天：复习昨天的，理解java特性

第七天：String类

　　　1.　两种不同的对象实例化方式

　　　　　　采用直接赋值字符串的形式为String类对象实例化；

　　　　　　　如：String str="Hello",

　　　　　　采用String类的构造方法为String类的对象实例化，String 类的构造为：public String（String str)

　　　　　　　　如：String str =new String("String")

　　　2.字符串的比较

　　　　　　String类中"=="和"equals()"的区别？

　　　　　　a.==：比较的是两个字符串内存地址的数值是否相等，属于数值比较；

　　　　　　b.equals():比较的是两个字符串的内容，属于内容比较。

　　注：字符串常量本身是一个String类的匿名对象。什么是匿名对象？前面已经讲过，匿名对象就是指没有栈内存指向的堆内存空间，就是一个匿名对象。

这里还讲到一个关于编译器优化的问题，比如String s="aa"+"bb"+"cc"在我们看来是占用了3个堆内存空间，但是经过编译器优化过后，就变成String s="aabbcc"，从而会节省空间，这也是Java高级语言的神奇之处。

　　　3.String类两种实例化方式的区别

　　　　　直接赋值：String str=“Hello”；

　　　　　　如果String str1=“Hello”；

　　　　　　String str2=“Hello”；

　　　　　　String str3=“Hello”；

　　　　　　那么str1==str2==str3;

　　　　　解释：直接赋值操作中字符串都相同的原因：直接赋值会将字符串的内容放入到池中，以供其他继续使用直接赋值方式的String对象使用，如果新声明的字符串内容不再池中时，则会开辟一个新的，继续放入池中，以供下次使用。也就是说上面的3个String类，str1 str2 str3指向的是一个堆内存，这个堆内存中存的是“Hello”。

　　　　　构造方法赋值：String str=new String("Hello")

　　　　　因为每一个字符串都是一个String类的匿名对象，所以首先会在堆内存中开辟一块空间保存字符串“Hello”，而后又使用了关键字new，开辟了另一块堆内存空间，不过真正使用的是用关键字new开辟的堆内存，而之前定义的字符串常量的堆内存空间将不会有任何的栈内存指向，就会成为垃圾，等待被GC回收。所以在使用构造方法赋值时，实际上创建了两个String类的实例化对象。

　　　　通过比较，在日后的所有开发中，String对象的实例化永远都采用直接赋值的方式完成。

　　　4.String类的常用方法。

　　　　通过方法public int length()求出字符串s的长度；

　　　　public int lastIndexOf(String str),表示从后向前查找字符串的位置，找不到返回-1；

　　　　public int indexOf(String str,int fromIndex) 由指定位置向后查找字符串位置，找不到返回=-1；

第八天：static关键字、单向链表等　

　　　　static定义属性：static String country="北京";

　　　　使用类名称访问static属性：static属性最好直接通过类名称来进行调用，使用“类名称.static属性”的方式来完成。

　　　　Person.country=“北京”；

　　　　可以在没有任何实例化对象时进行static属性的调用。

　　　　static 定义的方法不能调用非static的方法或属性；

　　　　非static定义的方法可以调用static的属性或方法。

第九天：单向链表

今天主要是学习上次没有学完的单向，话不多说，上代码！

Node类：

package com.cqvie.lianbiao;

public class Node {
 public String data;
 public Node next;


}

Link类：

package com.cqvie.lianbiao;

public class Link {//带头节点的单向链表
  private Node head=null;
  public Link(){//构造方法
   head=new Node();
   head.next=null;
  }
     public void add(String data){//在末尾添加节点
      Node a=head;
      while(a.next!=null) a=a.next;//找尾节点
      Node tmp=new Node();//新建节点tmp
      tmp.data=data;
      tmp.next=null;
      a.next=tmp;//连接到尾节点之后
     }
     public void addAll(String data[]){
      
     }
     public int size(){//求链表的长度
      Node a=head;
      int n=0;
         while(a.next!=null) {
       n=n+1;
       a=a.next; 
      }
      return n;
     }
     public boolean isEmpty(){//判断链表是否为空
        return head.next==null;
     }
     public boolean contains(String data){//判断链表中是否含有某节点
      Node a=head;
      while(a.next!=null){
       a=a.next;
       if(a.data.equals(data))
        return true;
      }
      return false;
      
     }
     public void remove(String data){//删除一个节点
      Node p=head;
      Node q;
      while(p.next!=null){
       q=p;
       p=p.next;
       if(p.data.equals(data))
       q.next=p.next;   
      }
     }
     public String[] toArray(){
      return null;
     }
     public String get(int index){
      return null;
     }
     public void clear(){
      
     }
    public String print(){//将链表所有节点连接成一个字符串并输出
     Node a=head;
     String s="";
     while(a.next!=null){
         a=a.next;
         s+=a.data+"-->";
     }
     return s;
    }
}

Test类：

package com.cqvie.lianbiao;

public class Test {

 public static void main(String[] args) {
  Link link=new Link();
        link.add("节点1");
        link.add("节点2");
        link.add("节点3");
        System.out.println("这个链表是否为空："+link.isEmpty());
        System.out.println("这个链表的长度:"+link.size());
        System.out.println("这个链表是:"+link.print());
        System.out.println("这个链表中是否有：“节点3”："+link.contains("节点3"));
        link.remove("节点2");
        System.out.println("删除节点2后:"+link.print());

 }

}

输出结果：

这个链表是否为空：false
这个链表的长度:3
这个链表是:节点1-->节点2-->节点3-->
这个链表中是否有：“节点3”：true
删除节点2后:节点1-->节点3-->

　　今天的学习感觉到小吃力，主要是对JAVA的结构不熟，还有以前的Ｃ代码掌握不是很牢固，比如，删除节点的操作，在C中的代码没安全掌握，在这里换个结构，感觉很吃力。所以，基础很重要。这些还没写完，后天补五一假课，再战!

第十天：链表、接口、继承性

　　1.链表：今天接着前几天学习的java封装思想。还是链表那个例子，今天把这部分学完了。

Node类：

package com.cqvie.lianbiao;

public class Node {
 public Object data;
 public Node next;
}

Link类：

package com.cqvie.lianbiao;
//有/**/的代码部分表示没有用tail来存尾指针，和size来存长度时的代码。其中61-63行（下划线）同理。
public class Link {//带头节点的单向链表
  private Node head,tail;//tail存放尾节点指针
  private int size;//长度    
  public Link(){//构造方法
   head=new Node();
   head.next=null;
   tail=head;
  }
     public void add(Object data){//在末尾添加节点
  /*    Node a=head;
      while(a.next!=null) a=a.next;//找尾节点
      Node tmp=new Node();//新建节点tmp
      tmp.data=data;
      tmp.next=null;
      a.next=tmp;//连接到尾节点之后
   */
      Node tmp=new Node();
      tmp.data=data;
      tmp.next=null;
      tail.next=tmp;
      tail=tmp;//调整尾指针
      size++;//长度调整
     }
     public void addAll(Object data[]){
    /*  Node p=head;
      while(p.next!=null) p=p.next;//找尾结点
      for(int i=0;i<data.length;i++){
       Node tmp=new Node();//新建节点
       tmp.data=data[i];
       tmp.next=null;
       p.next=tmp;//连接到尾节点之后 
      }
    */
      for(int i=0;i<data.length;i++)
       this.add(data[i]);
     }
     public int size(){//求链表的长度
   /*   Node a=head;
      int n=0;
         while(a.next!=null) {
       n=n+1;
       a=a.next; 
      }
      return n;
    */
      return size;
     }
     public boolean isEmpty(){//判断链表是否为空也可用size是否为0判断
        return head.next==null;
     }
     public boolean contains(Object data){//判断链表中是否含有某节点
      Node a=head;
      while(a.next!=null){
       a=a.next;
       if(a.data.equals(data))
        return true;
      }
      return false;
      
     }
     public void remove(Object data){//删除一个节点
      Node p=head;
      Node q;
      while(p.next!=null){
       q=p;
       p=p.next;
       if(p.data.equals(data)){
       q.next=p.next; 
       if(p==tail)
          tail=q; 
          size--;
       } 
      }
      
     }
     public Object[] toArray(){
      return null;
     }
     public Object get(int index){
      Node a=head;
      int n=0;
      while(a!=null){
       if(n==index){
        return a.data;
       }
       n++;
       a=a.next;
      }
      return null;
     }
     public void clear(){
     //head.next=null;//这一句可以代替下面语句，但是直接断掉头节点，回收效率较低。
      Node a=head;
      Node b;
      while(a.next!=null){
       b=a.next;
       a.next=null;
       a=b;
       
      }
      tail=head;
      size=0;
     }
    public Object print(){//将链表所有节点连接成一个字符串并输出
     Node a=head;
     String s="";
     while(a.next!=null){
         a=a.next;
         s+=a.data+"-->";
     }
     return s;
    }
}

Test类：

package com.cqvie.lianbiao;

public class Test {

 public static void main(String[] args) {
      Link link=new Link();
      link.add("节点1");
        link.add("节点2");
        link.add("节点3");
        System.out.println("这个链表是:"+link.print());
        System.out.println("这个链表是否为空："+link.isEmpty());
        System.out.println("这个链表的长度:"+link.size());
        
        System.out.println("这个链表中是否有：“节点3”："+link.contains("节点3"));
        link.remove("节点2");
        System.out.println("删除节点2后:"+link.print());
        System.out.println("获得第一个节点:"+link.get(1));

    }

}

输出结果：

这个链表是:节点1-->节点2-->节点3-->
这个链表是否为空：false
这个链表的长度:3
这个链表中是否有：“节点3”：true
删除节点2后:节点1-->节点3-->
获得第一个节点:节点1

上面这些代码，老师说在一个小时内，独立写出来，就是封装性入门了。

　　2.继承

然后讲了继承性：

Animal：

package com.cqvie.jicheng;

public class Animal {
     private String name;

  public String getName() {
  return name;
 }

 public void setName(String name) {
  this.name = name;
 }
     public void tell(){
      System.out.println("动物叫");
     }
}

 

Cat：

package com.cqvie.jicheng;


public class Cat extends Animal{
    public void tell(){
     System.out.println("喵~");
    }
  }

 

 

Dog：

package com.cqvie.jicheng;

public class Dog extends Animal {
    public void tell(){
     System.out.println("汪~");
    }
}

 

Sheep：

package com.cqvie.jicheng;

public class Dog extends Animal {
    public void tell(){
     System.out.println("汪~");
    }
}

 

Test：

package com.cqvie.jicheng;

public class Test {

 public static void main(String[] args) {
  Animal[] a=new Animal[4];
  a[0]=new Animal();
  a[1]=new Cat();
  a[2]=new Dog();
  a[3]=new Sheep();
  for(int i=0;i<a.length;i++)
   a[i].tell();
 }

}

 

输出结果：

动物叫
喵~
汪~
咩~

　　3.接口

还学了接口：

USB：

package USB;

public interface USB {
     public void insert();//插入
     public void writeData(String s);//写入数据
     public String readData();//读取数据
     public void pop();//弹出
}

UDISk：

package USB;

public class UDisk implements USB {

 public void insert() {
  System.out.println("插入U盘");

 }

 public void writeData(String s) {
  System.out.println("写入数据"+s);

 }

 public String readData() {
        return "hello";
 }

 public void pop() {
  System.out.println("弹出U盘");
     
 }

}

 

Test：

package USB;

public class Test {

 public static void main(String[] args) {
  USB usb=new UDisk();
  usb.insert();
  usb.writeData("ABC");
  String s= usb.readData();
  System.out.println("读出："+s);
  usb.pop();

 }

}

输出结果：

插入U盘
写入数据ABC
读出：hello
弹出U盘

感想：

一开始不了解或者说是对JAVA的特性不熟悉，不知道类与类之间的联系，对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(); python12-面向对象初阶
 [Lua学习]面向对象之创建类的对象
 [Lua学习]面向对象之创建类的对象
 java之面向对象（中）
 java之面向对象（中）
 TypeScript之面向对象初体验

JAVA学习面向对象之 扑克牌（初）

JAVA学习面向对象之扑克牌（初）