精华内容
下载资源
问答
  • 1、定义学生类Student,包含学号、姓名、成绩三个属性,默认构造方法、带参数构造方法; 2、Student类实现Comparable接口,并实现compareTo方法(按照成绩属性比较大小); 3、定义测试类,创建5个学生对象,并使用...

    第9章 对象和类

    第10章 面对对象思考

    第11章 继承和多态

    第12章 异常处理和文本I/O

    第13章 抽象类和对象

    主要:实现Comparable接口

    题目描述:作业内容要求:

    1、定义学生类Student,包含学号、姓名、成绩三个属性,默认构造方法、带参数构造方法;

    2、Student类实现Comparable接口,并实现compareTo方法(按照成绩属性比较大小);

    3、定义测试类,创建5个学生对象,并使用Arrays.sort()方法对5个学生对象排序。

    可能的Java代码:

    /**
     *  方便输入和测试的原因,把属性  姓名和学号  给隐藏忽略输入了,需要的自己改下  几个null值为name1、mark1.....mark4。   
     */
    /**
     * @author XXXXX
     *  2、Student类实现Comparable接口,并实现compareTo方法(按照成绩属性比较大小);---->这句话后面一句不懂  
     * 
     */
     //暂时不想改了,出了错误,只满足第二局前一部分,后一部分,有可能在Student类中实现????应该不是在Student类中实现实现Comparable接口吧。。。。。。那样的话,怎么实现ComparableStudent???最多在Student类实现compareTo方法(按照成绩属性比较大小),然后在ComparableStudent类中实现Comparable接口吧。。。。。。。。。。。。
    import java.util.Scanner;
    	public class Main
    	{
    		
    		public static void main(String[] args) {
    			Scanner sc=new Scanner(System.in);
    			
    			/*System.out.print("Enter the mark of Student1: ");
    			String mark1=sc.next();
    			System.out.print("Enter the name of Student1: ");
    			String name1=sc.next();*/
    			System.out.print("Enter the grade of Student1: ");
    			double grade1=sc.nextDouble();
    			
    			/*System.out.print("Enter the mark of Student2: ");
    			String mark2=sc.next();
    			System.out.print("Enter the name of Student2: ");
    			String name2=sc.next();*/
    			System.out.print("Enter the grade of Student2: ");
    			double grade2=sc.nextDouble();
    			
    			/*System.out.print("Enter the mark of Student3: ");
    			String mark3=sc.next();
    			System.out.print("Enter the name of Student3: ");
    			String name3=sc.next();*/
    			System.out.print("Enter the grade of Student3: ");
    			double grade3=sc.nextDouble();
    			
    			/*System.out.print("Enter the mark of Student4: ");
    			String mark4=sc.next();
    			System.out.print("Enter the name of Student4: ");
    			String name4=sc.next();*/
    			System.out.print("Enter the grade of Student4: ");
    			double grade4=sc.nextDouble();
    			
    			/*System.out.print("Enter the mark of Student5: ");
    			String mark5=sc.next();
    			System.out.print("Enter the name of Student5: ");
    			String name5=sc.next();*/
    			System.out.print("Enter the grade of Student5: ");
    			double grade5=sc.nextDouble();							
                System.out.println();	
                
    				ComparableStudent student1=new ComparableStudent(null, null, grade1);
    				ComparableStudent student2=new ComparableStudent(null, null, grade2);
    				ComparableStudent student3=new ComparableStudent(null, null, grade3);
    				ComparableStudent student4=new ComparableStudent(null, null, grade4);
    				ComparableStudent student5=new ComparableStudent(null, null, grade5);	
    				
    				ComparableStudent student6 = (ComparableStudent)Max.max(student1, student2);
    				ComparableStudent student7 = (ComparableStudent)Max.max(student3, student4);
    				ComparableStudent student8 = (ComparableStudent)Max.max(student6, student7);
    				
    				ComparableStudent student9 = (ComparableStudent)Max.max(student5, student8);
    								
    				System.out.println("The Student1's Grade is " + student1.getGrade());
    				System.out.println("The Student2's Grade is " + student2.getGrade());
    				System.out.println("The Student3's Grade is " + student3.getGrade());
    				System.out.println("The Student4's Grade is " + student4.getGrade());
    				System.out.println("The Student5's Grade is " + student5.getGrade());
    				System.out.println();
    				
    				ComparableStudent[] students= {
    						new ComparableStudent(null, null, grade1),
    						new ComparableStudent(null, null, grade2),
    						new ComparableStudent(null, null, grade3),
    						new ComparableStudent(null,null, grade4),
    						new ComparableStudent(null, null, grade5),
    				};
    				
    				java.util.Arrays.sort(  students);
    				
    				for(Student student:students) 
    				{
    					System.out.println(student.getGrade());
    				}
    		}
    	}
    
    	class Student
    	{
    		String  mark;
    		String  name;
    		double  grade;
    		Student()
    		{
    			
    		}
    			
    		Student(String  mark,String name,double grade)
    		{
    			this.mark=mark;
    			this.name=name;
    			this.grade=grade;
    		}
    		
    		void setMark(){
    			this.mark=mark;			
    		}
    		public String getMark(String mark){
    			return mark;
    		}
    		void setNamek(){
    			this.name=name;			
    		}
    		public String getName(String name){
    			return name;
    		}
    		void setGrade(){
    			this.grade=grade;			
    		}
    		public double getGrade(){
    			return grade;
    		}
    		
    	}
    	
    	class ComparableStudent extends Student implements Comparable
    	{
    		
    		public ComparableStudent(String  mark,String name,double grade)
    		{
    			super(mark, name, grade);
    		}
    		
    		public int compareTo(Object  o)
    		{
    			if(getGrade()>((Student) o).getGrade())
    			{	
    				return 1;	
    			}
    			
    			else if(getGrade()<((Student) o).getGrade())
    			{	
    				return -1;	
    			}
    			else
    			{
    				return 0;
    			}
    
    		}
    		//@Override
    		public String toString() 
    		{
    			return super.toString()+"mark: "+getMark(mark)+" name"+getName(name)+"grade:" +getGrade();
    			/输出只有成绩,没有学号和姓名
    		}
    }
    	class Max
    	{
    		public static ComparableStudent max(ComparableStudent o1, ComparableStudent o2)
    		{
    			if (o1.compareTo(o2) > 0)
    				return o1;
    			else
    				return o2;
    		}
    		
    	}	
    

    样例运行结果:
    在这里插入图片描述

    END

    展开全文
  • 第二个方面:以对象的某一个属性的角度去比较,例如以对象的年龄、出生年月、成绩分数、姓氏字母等。从最新的JDK8而言,有种实现对象比较的方法:一、覆写Object类的equals()方法,即直接写在...

    Java中经常会涉及到对象数组的排序问题,那么就涉及到对象之间的比较问题。

    通常对象之间的比较可以从两个方面去看:

    第一个方面:对象的地址是否一样,是否引用自同一个对象。这种方式可以直接使用“==“来完成。

    第二个方面:以对象的某一个属性的角度去比较,例如以对象的年龄、出生年月、成绩分数、姓氏字母等。

    从最新的JDK8而言,有三种实现对象比较的方法:

    一、覆写Object类的equals()方法,即直接写在类里面;

    二、继承Comparable接口,并实现compareTo()方法;

    三、定义一个单独的对象比较器,继承自Comparator接口,实现compare()方法。

    由于使用的排序方式的不同,具体选择哪种方法来实现对象的比较也会有所不同。

    方式1: 覆写equals()方法

    覆写equals()方法,一般用于自己实现对象数组排序的情况,而对于要使用java内置的排序算法时,使用后面两种方式都是可行的。

    方式2: 继承Comparable接口,并实现 compareTo()方法

    这种方式就是让自己编写的类继承Comparable接口,并实现compareTo()方法,这种情况下,在使用java.util.Arrays.sort() 方法时,不用指定具体的比较器,sort()方法会使用对象自己的比较函数来完成对象的排序。

    方式3:继承自Comparator接口,实现compare()方法

    一般使用以上两种方法就能够满足实际的开发问题,但是当出现以下情况时,就需要用到Comparator接口:要在已经开发好的代码的基础上完善对象的比较功能时,又不想更改之前的代码,这种情况下,从JDK1.8之后出现了Comparator接口,是对这种情况的一个弥补。

    这种情况下,需要单独定义一个对象比较器,继承Comparator接口,并实现compare()方法。

    以上三种实现方式的示例代码如下:

    package com.mymaven.javademo;

    import java.util.ArrayList;

    import java.util.Arrays;

    import java.util.Collections;

    import java.util.Comparator;

    import java.util.List;

    /**

    * @since 2017.03.31

    * @author mimvp

    *

    */

    class Student {

    private String name;

    private double score;

    public Student(String name, double score) {

    this.name = name;

    this.score = score;

    }

    public String getName() {

    return this.name;

    }

    public double getScore() {

    return this.score;

    }

    @Override

    public String toString(){

    return "Student:name: " + this.name + "; score: " + this.score;

    }

    // 方式1: 覆写equals()方法

    public int equals(Student s) {

    int result = this.score > s.getScore() ? 1 : (this.score < s.getScore() ? -1 : 0);

    if(0 == result) {

    result = this.name.charAt(0) >= s.getName().charAt(0) ? 1 : -1;

    }

    return result;

    }

    }

    /**

    * 方式2: 继承Comparable接口,并实现 compareTo()方法

    */

    @SuppressWarnings("rawtypes")

    class Teacher implements Comparable {

    private String name;

    private double score;

    public Teacher(String name, double score) {

    this.name = name;

    this.score = score;

    }

    public String getName() {

    return this.name;

    }

    public double getScore() {

    return this.score;

    }

    @Override

    public String toString() {

    return "Teacher:name: " + this.name + "; score: " + this.score;

    }

    public int compareTo(Object obj) {

    Teacher t = (Teacher) obj;

    int result = this.score > t.score ? 1 : (this.score < t.score ? -1 : 0);

    if(result == 0) {

    result = this.name.indexOf(0) > t.name.indexOf(0) ? 1 : -1;

    }

    return result;

    }

    }

    /**

    * 方式3: 继承自Comparator接口,实现compare()方法

    */

    class StudentComparator implements Comparator {

    public int compare(Student s1, Student s2) {

    int result = s1.getScore() > s2.getScore() ? 1 : (s1.getScore() < s2.getScore() ? -1 : 0);

    if(0 == result) {

    result = s1.getName().indexOf(0) > s2.getName().indexOf(0) ? 1 : -1;

    }

    return result;

    }

    }

    /**

    * 主函数

    */

    public class JavaDemo {

    @SuppressWarnings("unchecked")

    public static void main(String[] args ) {

    System.out.println("hello world");

    // 方式1

    Student s1 = new Student("zzz", 80);

    Student s2 = new Student("bbb", 80);

    System.out.println(s1.getName() + " >= " + s2.getName() + " : " + s1.equals(s2));

    // 方式2

    List teachers = new ArrayList(10);

    teachers.add(new Teacher("ddd", 60));

    teachers.add(new Teacher("aaa", 60));

    teachers.add(new Teacher("bbb", 80));

    teachers.add(new Teacher("ccc", 70));

    Collections.sort(teachers);

    System.out.println(teachers);

    // 方式3

    Student[] students = new Student[] {

    new Student("ddd", 60),

    new Student("aaa", 60),

    new Student("bbb", 80),

    new Student("ccc", 70),

    };

    Arrays.sort(students, new StudentComparator());

    System.out.println(Arrays.deepToString(students));

    }

    }

    运行结果:

    hello world

    zzz >= bbb : 1

    [Teacher:name: aaa; score: 60.0, Teacher:name: ddd; score: 60.0, Teacher:name: ccc; score: 70.0, Teacher:name: bbb; score: 80.0]

    [Student:name: aaa; score: 60.0, Student:name: ddd; score: 60.0, Student:name: ccc; score: 70.0, Student:name: bbb; score: 80.0]

    1. Comparator 和 Comparable 相同的地方

    他们都是java的一个接口, 并且是用来对自定义的class类对象的比较大小,什么是自定义class:

    如 public class Person{ String name; int age }

    当我们有这么一个personList,里面包含了person1, person2, persion3....., 我们用Collections.sort( personList ), 是得不到预期的结果的. 这时肯定有人要问, 那为什么可以排序一个字符串list呢:

    如 StringList{"hello1" , "hello3" , "hello2"}, Collections.sort( stringList ) 能够得到正确的排序, 那是因为

    String 这个对象已经帮我们实现了 Comparable接口 , 所以我们的 Person 如果想排序, 也要实现一个比较器。

    2. Comparator 和 Comparable 的区别

    Comparable

    Comparable 定义在 Person类的内部:

    public class Persion implements Comparable {..比较Person的大小..}

    因为已经实现了比较器,那么我们的Person现在是一个可以比较大小的对象了,它的比较功能和String完全一样,可以随时随地的拿来

    比较大小,因为Person现在自身就是有大小之分的。Collections.sort(personList)可以得到正确的结果。

    Comparator

    Comparator 是定义在Person的外部的, 此时我们的Person类的结构不需要有任何变化,如

    public class Person{ String name; int age },

    然后我们另外定义一个比较器:

    public PersonComparator implements Comparator() {..比较Person的大小..}

    在PersonComparator里面实现了怎么比较两个Person的大小. 所以,用这种方法,当我们要对一个 personList进行排序的时候,

    我们除了了要传递personList过去, 还需要把PersonComparator传递过去,因为怎么比较Person的大小是在PersonComparator里面实现的, 如:

    Collections.sort( personList , new PersonComparator() )

    参考推荐:

    展开全文
  • 扎金花大小比较算法(Java版)

    万次阅读 2014-06-17 00:10:07
    1)采用面向对象方式实现,分别构造牌面值对象(枚举)、牌花色对象(枚举)、玩家张牌类型(枚举,如豹子、同花顺等)、一张扑克牌对应对象(一张牌有一牌面值属性、一花色属性)、玩家对象(玩家有3张扑克牌...


    注:以下算法说明仅限一副牌(不包含大小王)的情况

    1、扎金花规则说明(大家都懂的,这里做简单描述):

    1)玩家每人3张牌;

    2)牌面大小2、3、4、5、6、7、8、9、10(用T表示),J、Q、K、A,大小依次递增;

    3)牌的花色有黑桃(用H表示)、红心(用X表示)、梅花(用M表示)、方块(用F表示),大小依次递减;

    4)牌有豹子(3张牌数字大小相同)、同花顺、同花(此种未实现,有兴趣的玩家可以自己加上,或者欢迎和我交流)、顺子、对子、散牌几种类型,大小依次递减;

    5)玩家先比牌的类型,如先按照4)中的规则比较,如:当都是豹子时,则比较豹子的牌面值大小(如H9X9M9>F8X8M8;类型相同时,按照2)中的牌面值比较,如:H9X9M2>F8X8HA,M9H9M2<F9X9HA等,详情请自行搜索或者查看代码注释或者看测试用例说明;

    2、实现算法特点:

    1)采用面向对象方式实现,分别构造牌面值的对象(枚举)、牌的花色对象(枚举)、玩家三张牌的类型(枚举,如豹子、同花顺等)、一张扑克牌对应的对象(一张牌有一个牌面值属性、一个花色属性)、玩家对象(玩家有3张扑克牌,牌的类型属性)

    2)主要是通过Java Comparable 接口的compareTo实现比较功能,很方便对玩家手中的牌进行排序(调用Collections.sort方法实现),同事避免了很多if else 比较;

    3、上代码:

    1)牌面值枚举

    /*
     * <pre>
     * 文 件 名:  PorkActor.java
     * 描    述:  <描述>
     * 修改时间:  2014-6-15
     * </pre> 
     */
    package com.dobuy.zhajinhua;
    
    /**
     * <pre>
     * 每张扑克牌的牌面数字
     * 
     * </pre>
     */
    public enum PorkActor
    {
        TWO('2'), THREE('3'), FOUR('4'), FIVE('5'), SIX('6'), SEVEN('7'), EIGHT('8'), NIME('9'), TEN('T'), J('J'), Q('Q'), K(
            'K'), A('A');
        
        private char num;
        
        private PorkActor(char num)
        {
            this.num = num;
        }
        
        /**
         * 获取 num
         * 
         * @return 返回 num
         */
        private char getNum()
        {
            return num;
        }
        
        /**
         * <pre>
         * 根据牌面数字找到扑克牌对应的牌面枚举对象
         * 
         * @param num
         * @return
         * </pre>
         */
        public static PorkActor getPorkActor(char num)
        {
            for (PorkActor porkActor : PorkActor.values())
            {
                if (porkActor.getNum() == num)
                {
                    return porkActor;
                }
            }
            return null;
        }
    }
    

    2)牌的花色枚举

    /*
     * <pre>
     * 文 件 名:  PorkColor.java
     * 描    述:  <描述>
     * 修改时间:  2014-6-15
     * </pre> 
     */
    package com.dobuy.zhajinhua;
    
    /**
     * <pre>
     * 扑克牌花色
     * 
     * </pre>
     */
    public enum PorkColor
    {
        F('F'), M('M'), X('X'), H('H');
        
        /**
         * 牌的花色
         */
        private char color;
        
        private PorkColor(char color)
        {
            this.color = color;
        }
        
        /**
         * <pre>
         * 根据花色字符查找扑克牌的花色枚举对象
         * 
         * @param color
         * @return
         * </pre>
         */
        public static PorkColor getPorkColor(char color)
        {
            for (PorkColor porkColor : PorkColor.values())
            {
                if (porkColor.color == color)
                {
                    return porkColor;
                }
            }
            return null;
        }
    }
    

    3)一张扑克牌

    /*
     * <pre>
     * 文 件 名:  Pork.java
     * 描    述:  <描述>
     * 修改时间:  2014-6-15
     * </pre> 
     */
    package com.dobuy.zhajinhua;
    
    /**
     * <pre>
     * 一张扑克牌对象
     * 1.实现Comparable接口,通过compareTo方法进行比较大小
     * 2.比较规则:
     * 1)先看牌面数字,数字大的就大;
     * 2)牌面数字相同时,花色大的就大;
     * 
     * </pre>
     */
    public class Pork implements Comparable<Pork>
    {
        /**
         * 扑克牌的牌面数字
         */
        private PorkActor porkActor;
        
        /**
         * 扑克牌的花色
         */
        private PorkColor porkColor;
        
        /**
         * 长度为2的字符串,接收扑克牌的数字和花色:第0位为数字,第1位为花色 <默认构造函数>
         */
        public Pork(String porkAttr)
        {
            char porkActor = porkAttr.charAt(1);
            char porkColor = porkAttr.charAt(0);
            
            setPorkActor(PorkActor.getPorkActor(porkActor));
            setPorkColor(PorkColor.getPorkColor(porkColor));
        }
        
        /**
         * 获取 porkActor
         * 
         * @return 返回 porkActor
         */
        public PorkActor getPorkActor()
        {
            return porkActor;
        }
        
        /**
         * 设置 porkActor
         * 
         * @param 对porkActor进行赋值
         */
        public void setPorkActor(PorkActor porkActor)
        {
            this.porkActor = porkActor;
        }
        
        /**
         * 获取 porkColor
         * 
         * @return 返回 porkColor
         */
        public PorkColor getPorkColor()
        {
            return porkColor;
        }
        
        /**
         * 设置 porkColor
         * 
         * @param 对porkColor进行赋值
         */
        public void setPorkColor(PorkColor porkColor)
        {
            this.porkColor = porkColor;
        }
        
        /**
         * 重载方法
         * 
         * @return
         */
        @Override
        public int hashCode()
        {
            final int prime = 31;
            int result = 1;
            result = prime * result + ((porkActor == null) ? 0 : porkActor.hashCode());
            result = prime * result + ((porkColor == null) ? 0 : porkColor.hashCode());
            return result;
        }
        
        /**
         * 重载方法
         * 
         * @param obj
         * @return
         */
        @Override
        public boolean equals(Object obj)
        {
            if (this == obj)
                return true;
            if (obj == null)
                return false;
            if (getClass() != obj.getClass())
                return false;
            Pork other = (Pork)obj;
            if (porkActor != other.porkActor)
                return false;
            if (porkColor != other.porkColor)
                return false;
            return true;
        }
        
        /**
         * 重载方法
         * 
         * @param o
         * @return
         */
        @Override
        public int compareTo(Pork o)
        {
            // 先去比较牌面大小
            int compare = getPorkActor().compareTo(o.getPorkActor());
            
            // 牌面相同时
            if (compare == 0)
            {
                // 比较花色
                return getPorkColor().compareTo(o.getPorkColor());
            }
            return compare;
        }
        
        /**
         * 重载方法
         * 
         * @return
         */
        @Override
        public String toString()
        {
            return "Pork [porkActor=" + porkActor + ", porkColor=" + porkColor + "]";
        }
    }
    

    4)玩家

    /*
     * <pre>
     * 文 件 名:  PorkPlayer.java
     * 描    述:  <描述>
     * 修改时间:  2014-6-15
     * </pre> 
     */
    package com.dobuy.zhajinhua;
    
    import java.util.ArrayList;
    import java.util.Collections;
    import java.util.List;
    
    /**
     * <pre>
     * 扑克牌玩家
     * 
     * </pre>
     */
    public class PorkPlayer implements Comparable<PorkPlayer>
    {
        private String allPorks;
        
        /**
         * 玩家有三张扑克牌
         */
        private List<Pork> porks;
        
        /**
         * 三张扑克牌的类型:豹子、同花顺等
         */
        private PorkType porkType;
        
        /**
         * 每个玩家默认有3张扑克牌 <默认构造函数>
         */
        public PorkPlayer(String porksStr)
        {
            this.allPorks = porksStr;
            init(porksStr);
        }
        
        /**
         * 获取 allPorks
         * 
         * @return 返回 allPorks
         */
        public String getAllPorks()
        {
            return allPorks;
        }
        
        /**
         * <pre>
         * 根据发的3张牌计算出玩家的牌的类型
         * 
         * @param porksStr
         * </pre>
         */
        private void init(String porksStr)
        {
            porks = new ArrayList<Pork>(3);
            int index = 0;
            int size = porksStr.length();
            
            Pork pork = null;
            while (index < size)
            {
                pork = new Pork(porksStr.substring(index, index + 2));
                porks.add(pork);
                index += 2;
            }
            
            // 对三张牌从小到大排序
            Collections.sort(porks);
            
            // 确定三张牌的类型
            if (isBaozi())
            {
                porkType = PorkType.BAOZI;
            }
            else if (isTonghuashun())
            {
                porkType = PorkType.TONGHUASHUN;
            }
            else if (isShunzi())
            {
                porkType = PorkType.SHUNZI;
            }
            else if (isDuizi())
            {
                porkType = PorkType.DUIZI;
            }
            else
            {
                porkType = PorkType.SANPAI;
            }
        }
        
        /**
         * <pre>
         * 判断是否是豹子(豹子要求3张牌面大小相同)
         * @return
         * </pre>
         */
        private boolean isBaozi()
        {
            Pork pork = porks.get(0);
            for (int i = 1, size = porks.size(); i < size; i++)
            {
                if (pork.getPorkActor() != porks.get(i).getPorkActor())
                {
                    return false;
                }
            }
            return true;
        }
        
        /**
         * <pre>
         * 判断是否是顺子
         * @return
         * </pre>
         */
        private boolean isShunzi()
        {
            for (int i = 1, size = porks.size(); i < size; i++)
            {
                if (porks.get(i - 1).getPorkActor().compareTo(porks.get(i).getPorkActor()) != -1)
                {
                    return false;
                }
            }
            return true;
        }
        
        /**
         * <pre>
         * 判断是否是同花顺
         * 
         * @return
         * </pre>
         */
        private boolean isTonghuashun()
        {
            if (!isShunzi())
            {
                return false;
            }
            
            Pork pork = porks.get(0);
            for (int i = 1, size = porks.size(); i < size; i++)
            {
                if (pork.getPorkColor() != porks.get(i).getPorkColor())
                {
                    return false;
                }
            }
            return true;
        }
        
        /**
         * <pre>
         * 是否是对子
         * 
         * @return
         * </pre>
         */
        private boolean isDuizi()
        {
            for (int i = 1, size = porks.size(); i < size; i++)
            {
                if (porks.get(i - 1).getPorkActor().compareTo(porks.get(i).getPorkActor()) == 0)
                {
                    return true;
                }
            }
            return false;
        }
        
        /**
         * <pre>
         * 获取扑克玩家手中的对子对应的扑克牌(不区分花色)
         * 
         * @return
         * </pre>
         */
        private Pork getDuiziPork()
        {
            for (int i = 1, size = porks.size(); i < size; i++)
            {
                if (porks.get(i - 1).getPorkActor().compareTo(porks.get(i).getPorkActor()) == 0)
                {
                    return porks.get(i);
                }
            }
            return null;
        }
        
        /**
         * <pre>
         * 获取玩家手中非成对的那张牌
         * @return
         * </pre>
         */
        private Pork getNoDuiziPork()
        {
            // 玩家只有3张牌,且是对子,而牌又是经过排序的,前2张相等,则最后一张是不成对的,否则后2张成对,第0张不同
            if (porks.get(0).compareTo(porks.get(1)) == 0)
            {
                return porks.get(2);
            }
            else
            {
                return porks.get(0);
            }
        }
        
        /**
         * 获取 porkType
         * 
         * @return 返回 porkType
         */
        public PorkType getPorkType()
        {
            return porkType;
        }
        
        /**
         * 重载方法
         * 
         * @return
         */
        @Override
        public int hashCode()
        {
            final int prime = 31;
            int result = 1;
            result = prime * result + ((porkType == null) ? 0 : porkType.hashCode());
            result = prime * result + ((porks == null) ? 0 : porks.hashCode());
            return result;
        }
        
        /**
         * 重载方法
         * 
         * @param obj
         * @return
         */
        @Override
        public boolean equals(Object obj)
        {
            if (this == obj)
                return true;
            if (obj == null)
                return false;
            if (getClass() != obj.getClass())
                return false;
            PorkPlayer other = (PorkPlayer)obj;
            if (porkType != other.porkType)
                return false;
            if (porks == null)
            {
                if (other.porks != null)
                    return false;
            }
            else if (!porks.equals(other.porks))
                return false;
            return true;
        }
        
        /**
         * 重载方法
         * 
         * @return
         */
        @Override
        public String toString()
        {
            return "PorkPlayer [porks=" + porks + ", porkType=" + porkType + "]";
        }
        
        /**
         * 重载方法
         * 
         * @param o
         * @return
         */
        @Override
        public int compareTo(PorkPlayer o)
        {
            int compare = getPorkType().compareTo(o.getPorkType());
            // TODO
            if (compare == 0)
            {
                switch (getPorkType())
                {
                    /**
                     * 豹子、同花顺、顺子直接比较最大牌(最大牌会先比大小,再比花色)
                     */
                    case BAOZI:
                    case TONGHUASHUN:
                    case SHUNZI:
                    {
                        return porks.get(2).compareTo(o.porks.get(2));
                    }
                    case DUIZI:
                    {
                        /**
                         * 对子比较
                         */
                        Pork duizi1 = getDuiziPork();
                        Pork duizi2 = o.getDuiziPork();
                        // 先比较对子大小,对子大小相同时,比较散牌大小
                        if (duizi1.getPorkActor() == duizi2.getPorkActor())
                        {
                            compare = getNoDuiziPork().getPorkActor().compareTo(o.getNoDuiziPork().getPorkActor());
                            // 散牌大小相同时,比较对子中最大牌的花色
                            if (compare == 0)
                            {
                                return duizi1.getPorkColor().compareTo(duizi2.getPorkColor());
                            }
                            return compare;
                        }
                        else
                        {
                            // 对子大小不同时,直接比较对子大小
                            return duizi1.getPorkActor().compareTo(duizi2.getPorkActor());
                        }
                    }
                    case SANPAI:
                    {
                        // 散牌依次从最大数开始比较,只比较牌面值大小,如果相同,则从第二大值开始比较,直到不同或者全部比较完毕为止
                        for (int size = porks.size(), i = size - 1; i >= 0; i--)
                        {
                            compare = porks.get(i).getPorkActor().compareTo(o.porks.get(i).getPorkActor());
                            if (compare != 0)
                            {
                                return compare;
                            }
                        }
                        // 说明三张牌的牌面值全部相同,则比较最大牌的花色
                        return porks.get(2).getPorkColor().compareTo(o.porks.get(2).getPorkColor());
                    }
                }
            }
            
            return compare;
        }
    }
    

    5)单张扑克牌单元测试类

    /*
     * <pre>
     * 文 件 名:  PorkTest.java
     * 描    述:  <描述>
     * 修改时间:  2014-6-15
     * </pre> 
     */
    package com.dobuy.zhajinhua;
    
    import static org.junit.Assert.assertTrue;
    
    import org.junit.Test;
    
    /**
     * <pre>
     * <一句话功能简述>
     * 
     * </pre>
     */
    public class PorkTest
    {
        /**
         * <pre>
         * case 1:牌面大小不同时,比较牌面的大小
         * </pre>
         */
        @Test
        public void test1()
        {
            
            Pork pork1 = new Pork("H5");
            Pork pork2 = new Pork("X6");
            
            assertTrue(pork1.compareTo(pork2) < 0);
        }
        
        /**
         * <pre>
         * case 1:牌面大小相同时,比较牌的花色
         * </pre>
         */
        @Test
        public void test2()
        {
            Pork pork1 = new Pork("H5");
            Pork pork2 = new Pork("X5");
            
            assertTrue(pork1.compareTo(pork2) > 0);
        }
    }
    

    6)玩家单元测试类

    /*
     * <pre>
     * 文 件 名:  PorkPlayerTest.java
     * 描    述:  <描述>
     * 修改时间:  2014-6-16
     * </pre> 
     */
    package com.dobuy.zhajinhua;
    
    import static org.junit.Assert.assertTrue;
    
    import org.junit.Test;
    
    /**
     * <pre>
     * <一句话功能简述>
     * 
     * </pre>
     */
    public class PorkPlayerTest
    {
        @Test
        public void test1()
        {
            PorkPlayer player1 = new PorkPlayer("H2F2X2");
            assertTrue(player1.getPorkType() == PorkType.BAOZI);
            
            PorkPlayer player2 = new PorkPlayer("H2H3H4");
            assertTrue(player2.getPorkType() == PorkType.TONGHUASHUN);
            
            PorkPlayer player3 = new PorkPlayer("H2F3H4");
            assertTrue(player3.getPorkType() == PorkType.SHUNZI);
            
            PorkPlayer player4 = new PorkPlayer("H3F3H4");
            assertTrue(player4.getPorkType() == PorkType.DUIZI);
            
            PorkPlayer player5 = new PorkPlayer("H3F6H4");
            assertTrue(player5.getPorkType() == PorkType.SANPAI);
        }
        
        @Test
        public void test2()
        {
            /**
             * case 1:都是豹子时,比较大小
             */
            PorkPlayer player11 = new PorkPlayer("H2F2X2");
            PorkPlayer player12 = new PorkPlayer("HAFAXA");
            assertTrue(player11.compareTo(player12) < 0);
            
            /**
             * case 2:豹子大于同花顺
             */
            PorkPlayer player21 = new PorkPlayer("H2F2X2");
            PorkPlayer player22 = new PorkPlayer("H3H5H4");
            assertTrue(player21.compareTo(player22) > 0);
            
            /**
             * case 3:都是同花顺时,比较大小
             */
            PorkPlayer player31 = new PorkPlayer("H3H5H4");
            PorkPlayer player32 = new PorkPlayer("F5F6F7");
            assertTrue(player31.compareTo(player32) < 0);
            
            /**
             * case 4:同花顺大于顺子
             */
            PorkPlayer player41 = new PorkPlayer("H3H5H4");
            PorkPlayer player42 = new PorkPlayer("F5H6F7");
            assertTrue(player41.compareTo(player42) > 0);
            
            /**
             * case 5:都是顺子时,比较最大牌(先比较最大牌的牌面值,相同则比较花色)
             */
            PorkPlayer player51 = new PorkPlayer("H3X5H4");
            PorkPlayer player52 = new PorkPlayer("F5H6F7");
            assertTrue(player51.compareTo(player52) < 0);
            
            /**
             * case 6:顺子大于对子
             */
            PorkPlayer player61 = new PorkPlayer("H3X5H4");
            PorkPlayer player62 = new PorkPlayer("F5H7F7");
            assertTrue(player61.compareTo(player62) > 0);
            
            /**
             * case 7.1:都是对子时,比较对子大小
             */
            PorkPlayer player71 = new PorkPlayer("H3F5H5");
            PorkPlayer player72 = new PorkPlayer("XAH6FA");
            assertTrue(player71.compareTo(player72) < 0);
            
            /**
             * case 7.2:都是对子时,对子大小相同,比较散牌的大小
             */
            PorkPlayer player73 = new PorkPlayer("HAF5MA");
            PorkPlayer player74 = new PorkPlayer("XAH6FA");
            assertTrue(player73.compareTo(player74) < 0);
            
            /**
             * case 7.3:都是对子时,比较大小(对子大小相同,比较散牌的大小)
             */
            PorkPlayer player75 = new PorkPlayer("HAF5MA");
            PorkPlayer player76 = new PorkPlayer("XAH6FA");
            assertTrue(player75.compareTo(player76) < 0);
            
            /**
             * case 7.4:都是对子时,三张牌牌面值相同,比较对子中最大牌的花色
             */
            PorkPlayer player77 = new PorkPlayer("HAX5MA");
            PorkPlayer player78 = new PorkPlayer("XAM5FA");
            assertTrue(player77.compareTo(player78) > 0);
            
            /**
             * case 8:对子大于散牌
             */
            PorkPlayer player81 = new PorkPlayer("H3F5X3");
            PorkPlayer player82 = new PorkPlayer("FQH9F7");
            assertTrue(player81.compareTo(player82) > 0);
            
            /**
             * case 9.1:都是散牌时,比较最大牌的牌面值大小
             */
            PorkPlayer player91 = new PorkPlayer("H3F5HJ");
            PorkPlayer player92 = new PorkPlayer("X4H6FT");
            assertTrue(player91.compareTo(player92) > 0);
            
            /**
             * case 9.2:都是散牌时,最大牌面值相同时,比较第2大牌的牌面值大小
             */
            PorkPlayer player93 = new PorkPlayer("H3X5HJ");
            PorkPlayer player94 = new PorkPlayer("X4M2FJ");
            assertTrue(player93.compareTo(player94) > 0);
            
            /**
             * case 9.3:都是散牌时,最大、第2大牌面值相同时,比较最小牌的牌面值大小
             */
            PorkPlayer player95 = new PorkPlayer("H3X5HJ");
            PorkPlayer player96 = new PorkPlayer("X4M5FJ");
            assertTrue(player95.compareTo(player96) < 0);
            
            /**
             * case 9.4:都是散牌时,三张牌的牌面值大小全部相同,则比较最大牌的花色
             */
            PorkPlayer player97 = new PorkPlayer("H3X5HJ");
            PorkPlayer player98 = new PorkPlayer("X3M5FJ");
            assertTrue(player97.compareTo(player98) > 0);
        }
    }
    



    展开全文
  • JAVA类中private属性能否被继承

    千次阅读 2016-06-06 17:45:52
    java基础 讨论问题:类中private属性能否被继承?...2.给这三个类分别new一个对象,并比较各对象空间大小. 3.结果猜测:如果Test1==Test2>Test3则命题成立;如果Test1>Test2==Test3,则命题不成立. 上代码:(参考:

    java基础

    讨论的问题:类中private属性能否被继承?

    验证过程:

    1.分别建立三个类Test1/Test2/Test3,类Test2继承Test1,Test3与Test2为空类.

    2.给这三个类分别new一个对象,并比较各对象的空间大小.

    3.结果猜测:如果Test1==Test2>Test3则命题成立;如果Test1>Test2==Test3,则命题不成立.

    上代码:(参考:http://my.oschina.net/xianggao/blog/361584)

    import java.lang.instrument.Instrumentation;  
    import java.lang.reflect.Array;  
    import java.lang.reflect.Field;  
    import java.lang.reflect.Modifier;  
    import java.util.IdentityHashMap;  
    import java.util.Map;  
    import java.util.Stack;  
    
    public class MySizeOf {  
    
        static Instrumentation inst;  
    
        public static void premain(String agentArgs, Instrumentation instP) {  
           inst = instP;  
        }  
    
        public static long sizeOf(Object o) {  
           if(inst == null) {  
              throw new IllegalStateException("Can not access instrumentation environment.\n" +  
                 "Please check if jar file containing SizeOfAgent class is \n" +  
                 "specified in the java's \"-javaagent\" command line argument.");  
           }  
           return inst.getObjectSize(o);  
        }  
    
       /**
        * 递归计算当前对象占用空间总大小,包括当前类和超类的实例字段大小以及实例字段引用对象大小
        */
        public static long fullSizeOf(Object obj) {//深入检索对象,并计算大小  
           Map<Object, Object> visited = new IdentityHashMap<Object, Object>();  
           Stack<Object> stack = new Stack<Object>();  
           long result = internalSizeOf(obj, stack, visited);  
           while (!stack.isEmpty()) {//通过栈进行遍历  
              result += internalSizeOf(stack.pop(), stack, visited);  
           }  
           visited.clear();  
           return result;  
        }  
        //判定哪些是需要跳过的  
        private static boolean skipObject(Object obj, Map<Object, Object> visited) {  
           if (obj instanceof String) {  
              if (obj == ((String) obj).intern()) {  
                 return true;  
              }  
           }  
           return (obj == null) || visited.containsKey(obj);  
        }  
    
        private static long internalSizeOf(Object obj, Stack<Object> stack, Map<Object, Object> visited) {  
           if (skipObject(obj, visited)) {//跳过常量池对象、跳过已经访问过的对象  
               return 0;  
           }  
           visited.put(obj, null);//将当前对象放入栈中  
           long result = 0;  
           result += sizeOf(obj);  
           Class <?>clazz = obj.getClass();  
           if (clazz.isArray()) {//如果数组  
               if(clazz.getName().length() != 2) {// skip primitive type array  
                  int length =  Array.getLength(obj);  
                  for (int i = 0; i < length; i++) {  
                     stack.add(Array.get(obj, i));  
                  }  
               }  
               return result;  
           }  
           return getNodeSize(clazz , result , obj , stack);  
       }  
    
       //这个方法获取非数组对象自身的大小,并且可以向父类进行向上搜索  
       private static long getNodeSize(Class <?>clazz , long result , Object obj , Stack<Object> stack) {  
          while (clazz != null) {  
              Field[] fields = clazz.getDeclaredFields();  
              for (Field field : fields) {  
                  if (!Modifier.isStatic(field.getModifiers())) {//这里抛开静态属性  
                       if (field.getType().isPrimitive()) {//这里抛开基本关键字(因为基本关键字在调用java默认提供的方法就已经计算过了)  
                           continue;  
                       }else {  
                           field.setAccessible(true);  
                          try {  
                               Object objectToAdd = field.get(obj);  
                               if (objectToAdd != null) {  
                                      stack.add(objectToAdd);//将对象放入栈中,一遍弹出后继续检索  
                               }  
                           } catch (IllegalAccessException ex) {   
                               assert false;  
                      }  
                  }  
              }  
          }  
          clazz = clazz.getSuperclass();//找父类class,直到没有父类  
       }  
       return result;  
      }  
    }

    主函数:

    class Test1 //24
    {
    	private int a=1;
    	private long aa=1l;
    	
    }
    
    class	Test2 extends Test1 //32
    {
    }
    class	Test3 
    {
    }
    public class TestSize {
    	   public static void main(String []args) {
    	   System.out.println(MySizeOf.fullSizeOf(new Test1()));//打印Test1对象的大小
    	   System.out.println(MySizeOf.fullSizeOf(new Test2()));//打印Test2对象的大小
    	   System.out.println(MySizeOf.fullSizeOf(new Test3()));//打印Test3对象的大小
    	} 
    }

    执行及结果:

    1.先打包类MySizeOf.

    2.编译执行结果如下:


    结论:类的private的属性可以被继承.



    展开全文
  • 关于 发布在Maven Central和jCenter Java库上,该库比较2张相同大小的... 可以根据图像的大小和要求进行更改。 rectangleLineWidth 绘制矩形的线的宽度。 destination 结果目标文件。 minimalRectangleSize 最小
  • Comparator假设Hero有三个属性 name,hp,damage一个集合中放存放10个Hero,通过Collections.sort对这10个进行排序那么到底是hp小放前面?还是damage小放前面?Collections.sort也无法确定所以要指定到底按照哪种...
  • ,但是实际开发中我们需要比较对象的大小如何实现:使用两接口中的一 Comparable 或 Comparator。 二: 使用方法(Compare方法重写规则) < 如果当前对象this大于形参obj,则返回正整数; < 如果当前对象...
  • 本篇我们一起来学习一个比较重要容器控件,它是网页上经常用到控件,大家可以就把它理解为一个放东西盒子。这一篇我们来介绍一下div一些样式和属性。...效果如下:width、height:这两个属性分别控
  • 定义长方体类Cuboid,要求如下:(1)私有...调用方法(自己决定怎么写)比较他们的表面积大小 和 体积的大小比较三对即可。 说明:除了必须出现的部分,可自己选择添加方法或属性,接口或抽象类,不限种类数量。
  • 关于比较器,我们知道我们java数组中可以使用一个方法:Array.sort(array);...比如我们有三个学生,学生属性有id,name,age,我们可以使用id来排序,也可以使用age来排序。两者结果是不一样。下边我们来实现这...
  • java源码包---java 源码 大量 实例

    千次下载 热门讨论 2013-04-18 23:15:26
     QQ客户端登录界面,中部有三个JPanel,有一个叫选项卡窗口管理。还可以更新好友列表,响应用户双击事件,并得到好友编号,把聊天界面加入到管理类,设置密码保护等。 Java编写网页版魔方游戏 内容索引:JAVA...
  •  建议27: 谨慎包装类型的大小比较  建议28: 优先使用整型池  建议29: 优先选择基本类型  建议30: 不要随便设置随机种子 第3章 类、对象及方法  建议31: 在接口中不要存在实现代码  建议32: 静态变量...
  • 游戏规则:/* 一、创建一副扑克牌四种花色:黑桃、红桃、梅花、方片十种点数:2-10,J,Q,K,A,不考虑大小王二、创建两名玩家玩家至少有ID、姓名、手牌等属性,手牌为扑克牌集合、洗牌将之前创建“一副扑克牌”...
  • 建议27: 谨慎包装类型的大小比较/45 建议28: 优先使用整型池/46 建议29: 优先选择基本类型/48 建议30: 不要随便设置随机种子/49 第3章 类、对象及方法/52 建议31: 在接口中不要存在实现代码/53 建议32: 静态...
  • JAVA编程题:设计三个图形类? 题目要求:有三种图形类:三角形、矩形、圆,三角形属性三个顶点坐标,矩形属性为其左上角和右下角两点坐标,圆为圆心和圆上任一点坐标。它们都有颜色、线型粗细属性,都有求面积...
  • java画板

    2017-12-05 19:34:25
    (3)设置边框布局,因为整个画板大致为左边部分,中间部分,菜单栏三个部分,用边框布局比较合适; (4)给窗体添加左面板,中间面板; (5)给左面板添加按钮,并设置按钮图片和效果; (6)给左面板添加左子面板...
  • QQ客户端登录界面,中部有三个JPanel,有一个叫选项卡窗口管理。还可以更新好友列表,响应用户双击事件,并得到好友编号,把聊天界面加入到管理类,设置密码保护等。 Java编写网页版魔方游戏 内容索引:JAVA...
  • QQ客户端登录界面,中部有三个JPanel,有一个叫选项卡窗口管理。还可以更新好友列表,响应用户双击事件,并得到好友编号,把聊天界面加入到管理类,设置密码保护等。 Java编写网页版魔方游戏 内容索引:JAVA...
  • 建议27: 谨慎包装类型的大小比较 45 建议28: 优先使用整型池 46 建议29: 优先选择基本类型 48 建议30: 不要随便设置随机种子 49 第3章 类、对象及方法 52 建议31: 在接口中不要存在实现代码 53 建议32: ...
  • java源码包2

    千次下载 热门讨论 2013-04-20 11:28:17
     QQ客户端登录界面,中部有三个JPanel,有一个叫选项卡窗口管理。还可以更新好友列表,响应用户双击事件,并得到好友编号,把聊天界面加入到管理类,设置密码保护等。 Java编写网页版魔方游戏 内容索引:JAVA...
  • java源码包3

    千次下载 热门讨论 2013-04-20 11:30:13
     QQ客户端登录界面,中部有三个JPanel,有一个叫选项卡窗口管理。还可以更新好友列表,响应用户双击事件,并得到好友编号,把聊天界面加入到管理类,设置密码保护等。 Java编写网页版魔方游戏 内容索引:JAVA...
  • java源码包4

    千次下载 热门讨论 2013-04-20 11:31:44
     QQ客户端登录界面,中部有三个JPanel,有一个叫选项卡窗口管理。还可以更新好友列表,响应用户双击事件,并得到好友编号,把聊天界面加入到管理类,设置密码保护等。 Java编写网页版魔方游戏 内容索引:JAVA...
  • 要了解面向对象编程(OOP)基本概念,需要理解 OOP 的三个主要概念,它们撑起 了整个 OOP 框架。这三个概念是:封装、继承性和多态性。除此以外,还需了解对象、 类、消息、接口、及抽象等概念。 2.2.1 ...
  • 但通常情况下,由于Java Bean是被容器所创建(如Tomcat),所以Java Bean应具有一无参构造器,另外,通常Java Bean还要实现Serializable接口用于实现Bean持久性。Java Bean实际上相当于微软COM模型中本地...
  • 1)Worker类含有name,age,salary三个属性 2)取值,赋值方法可省略 3)比较时,先比较工人年龄大小,年龄小排在前面。如果两个工人年龄相同,则比较工人姓名(姓名可以是中文) 4)编写测试类,向集合中添加三条数据...
  • 扑克牌小游戏 第一版本 我写这个扑克牌小游戏是一个很基础的java控制台程序。这个扑克牌游戏主要游戏过程是:首先创建一副扑克牌,创建完扑克牌之后要进行洗牌,...第二步:我们创建玩家类,玩家拥有三个属性,一个
  • java面试题典 java 面试题 经典

    热门讨论 2010-06-18 13:42:36
    50. List、Map、Set三个接口,存取元素时,各有什么特点? 16 51. 说出一些常用类,包,接口,请各举5个 常用类; 16 52. Anonymous Inner Class (匿名内部类) 是否可以extends(继承)其它类,是否可以 ...
  • java面试题

    2018-01-01 15:35:15
    84.9. 题目1:用1、2、2、3、4、5这六数字,用java写一main函数,打印出所有不同排列,如:512234、412345等,要求:"4"不能在第位,"3"与"5"不能相连. 117 84.10. 写一方法,实现字符串反转,如:输入...

空空如也

空空如也

1 2 3 4 5 ... 8
收藏数 160
精华内容 64
关键字:

java比较三个属性的大小

java 订阅