java之 ------ 类的封装、继承和多态(一)

问题:① 完善set()方法,保证获得正确的日期值(合法性);

② 将tomorrow()和yestoday()方法合并为以下daysAfter()方法,并增加一些方法:

public int getWeek()   //返回当前日期对应的星期几,范围为0~6

public String toWeekString()   //返回当前日期对应星期几的中文字符串

public boolean before(MyDate d)  //判断是否在指定日期之前

public int daysBetween(MyDate d) //返回当前日期与日期d之间相距的天数

public boolean equals(Object obj)  //比较两个对象是否相等

import java.util.Calendar;
import java.util.Scanner;
public class MyDate2 {
    int year,month,day;
    boolean isCorrect=true;
    private static int thisYear;
    static {
       thisYear=Calendar.getInstance().get(Calendar.YEAR); //获得当前日期对象中的年份值
    }
    public MyDate2(int year, int month, int day) {
        this.set(year, month, day);
    }
    public MyDate2()  {
        this(1970,1,1);                          //调用本类已声明的其他构造方法
    }
    public MyDate2(MyDate2 d)  {
    	   this.set(d);
    }
    public void set(int y, int m, int d) {
    	if(y<1){
    		System.out.println("Input Year Is Error !!!");
    		this.isCorrect=false;
    		return ;
    	}if(m<1||m>12){
    		System.out.println("Input Month Is Error !!!");
    		this.isCorrect=false;
    		return ;
    	}
    	if(day<=0 || day>daysOfMonth() ){
    		System.out.println("Input Day Is Error !!!");
    		this.isCorrect=false;
    		return ;
    	}
        this.year = y;
        this.month = m;
        this.day = d ;
    }
    public void set(MyDate2 d) {
        set(d.year, d.month, d.day);             //调用同名成员方法,不能使用this()
    }
    public String toString(){
        return this.year+"年"+this.month+"月"+this.day+"日";
    }
    public static int getThisYear(){
        return thisYear;                         //访问静态成员变量
    }
    public static boolean isLeapYear(int year)  {
        return year%400==0 || year%100!=0 && year%4==0;
    }
    public boolean isLeapYear() {
        return isLeapYear(this.year);            //调用静态方法
    }
    public boolean equals(MyDate2 d)  {                                            //this指代调用本

方法的当前对象
        return this==d || d!=null && this.year==d.year && this.month==d.month && this.day==d.day;
    }
    public boolean equals(Object obj)  {
        if (this==obj)                           //this指代调用当前方法的对象
            return true;
        if (obj instanceof MyDate2) {
            MyDate2 d = (MyDate2)obj;              //类型强制转换
            return this.year==d.year && this.month==d.month && this.day==d.day;
        }
        return false;
    }
    public static int daysOfMonth(int year, int month) {
        switch (month)                           //计算每月的天数
        {
            case 1: case 3: case 5: case 7: case 8: case 10: case 12:  return 31;
            case 4: case 6: case 9: case 11:  return 30;
            case 2:  return isLeapYear(year)?29:28;
            default: return 0;
        }
    }
    public int daysOfMonth()     {
        return daysOfMonth(this.year, this.month);
    }
    public void tomorrow() {
        this.day++;                              //通过this改变当前对象的值,没有返回值
        if (day>this.daysOfMonth()){
            day=1;
            month++;
            if (month>12)
            {
                month=1;
                year++;
            }
        }
    }
    public MyDate2 yestoday()     {
        MyDate2 yes=new MyDate2(this);             //执行拷贝构造方法,创建新实例,没有改变当前对象

this
        yes.day--;
        if (yes.day==0) {
            yes.month--;
            if (yes.month==0){
                yes.month=12;
                yes.year--;
            }
            yes.day = daysOfMonth(yes.year, yes.month);
        }
        return yes;                              //返回对象引用
    }
    public MyDate2 dayAfter(int n)     {
        MyDate2 yes=new MyDate2(this);             //执行拷贝构造方法,创建新实例,没有改变当前对象

this
        yes.day+=n;
        if (yes.day==0) {
            yes.month--;
            if (yes.month==0){
                yes.month=12;
                yes.year--;
            }
            yes.day = daysOfMonth(yes.year, yes.month);
        	//System.out.println("**"+yes.year+" "+yes.month+" "+yes.day);
        	return yes;
        }
         if (yes.day>this.daysOfMonth()){
            yes.day=1;
            yes.month++;
            if (yes.month>12)
            {
                yes.month=1;
                yes.year++;
            }
        }
        return yes;                              //返回对象引用
    }
    public int getSumDays(MyDate2 d){
    	int  sum=0;
    	for(int i=1;i<d.year;i++){
    		sum+=d.isLeapYear(i) ? 366 : 365;
    	}
    	for(int i=1;i<d.month;i++){
    		sum+=d.daysOfMonth(d.year,i);
    	}
    	sum+=d.day;
    	return sum;
    }
    public int getWeek(){
    	long sum=0;
    	int week;
    	for(int i=1;i<this.year;i++){
    		sum+=this.isLeapYear(i) ? 366 : 365;
    	}
    	for(int i=1;i<this.month;i++){
    		sum+=this.daysOfMonth(this.year,i);
    	}
    	sum+=this.day;
    	week=(int)sum%7;
    	return week;
    }
    public String toWeekString(){
    	switch (getWeek()){
    		case 0 : return "Sunday" ;
    		case 1 : return "Monday" ;
    		case 2 : return "Tuesay" ;
    		case 3 : return "Wednesday" ;
    		case 4 : return "Thursday" ;
    		case 5 : return "Friday" ;
    		default : return "Saturday" ;
    	}
    }
    public boolean before(MyDate2 d){
    	if(this.year<d.year){
    		return true;
    	}else if(this.year==d.year){
    		if(this.month<d.month){
    			return true;
    		}else if(this.month==d.month){
    			if(this.day<d.day){
    				return true;
    			}else{
    				return false;
    			}
    		}else{
    			return false;
    		}
    	}else{
    		return false;
    	}
    }
    public int daysBetween(MyDate2 d){
    	int a=getSumDays(d);
    	int b=getSumDays(this);
    	return Math.abs(a-b);
    }
}
class MyDate_ex
{
	public static void main(String args[])
    {
    	Scanner sc=new Scanner(System.in);
	   	System.out.println("Please input date : ");
    	while(sc.hasNext()){
	        MyDate2 d= new MyDate2(sc.nextInt(),sc.nextInt(),sc.nextInt());
	        if(d.isCorrect){
	        	System.out.println("If you want to konw yestoday date,please input -1 ");
	        	System.out.println("or tomorrow date,please input 1");
	        	System.out.println(d.dayAfter(sc.nextInt()));
	        	System.out.println("Week : "+d.getWeek()+" "+d.toWeekString());
	        	System.out.println("Input a cmparative date : ");
	        	MyDate2 r=new MyDate2(sc.nextInt(),sc.nextInt(),sc.nextInt());
	        	System.out.println(d.before(r));
	        	System.out.println("Date_d between Date_r have "+d.daysBetween(r)+" days");
	        }
	        System.out.println();
	   		System.out.println("Please input date : ");
    	}
    }
}
时间: 2024-10-08 04:30:13

java之 ------ 类的封装、继承和多态(一)的相关文章

黑马程序员--oc 类的封装 继承 和多态

------Java培训.Android培训.iOS培训..Net培训.期待与您交流! ------- 成员变量的命名规范: 成员变量名要以 _开头 作用: 1.可以让成员变量和get方法的名称区分开 2.可以和局部变量区分开,一看到以_开头的变量一般都是成员变量 封装: 在定义成员变量时,尽量不要用@public 这种写法 ,而是使用set方法和get方法 @interface Student : NSObject { int _age; } /* set方法: 作用:提供一个方法给外界设置成

类的封装 继承和多态

package 银行账户管理;import java.text.SimpleDateFormat;   //常用日期操作工具类import java.util.Calendar;     //使用默认时区和语言环境获得一个日历import java.util.Date;public class yinhang {  private String acount;     //账户  private String name;   //姓名  private String time;   //时间  

(1) 深入理解Java面向对象三大特性 封装 继承 多态

转眼已经工作快6年了,最开始做了2年J2EE:然后整了2年的数据仓库,主要是Cognos的报表开发:现在从事4G LTE核心网的开发,用的语言任然是Java,但写代码的机会不多,基本都是看代码找BUG,偶尔做点new feature也是在比较成熟的框架上复制.粘贴.修改,大部分时间还是在理解业务,钱多.事少.离家近,当时来这家公司图的是后面2点,2年过去了,英文水平有所提升,对敏捷开放也有一定的了解,但技术方面明显退步了或者说没有进步吧,本来以前也不怎么好,因为工作上用不到,自己也没怎么学习,所

day33 序列类型,绑定方法,类方法,静态方法,封装继承和多态

Python之路,Day20 = 序列类型,绑定方法,类方法,静态方法,封装继承和多态 序列是指有序的队列,重点在"有序". 一.Python中序列的分类 Python中的序列主要以下几种类型: 3种基本序列类型(Basic Sequence Types):list.tuple.range 专门处理文本的附加序列类型(Text Sequence Types):str 专门处理二进制数据的附加序列类型(Binary Sequence Types): bytes.bytearray.mem

Mysql数据库大量删除操作及谈面向对象中的封装继承和多态原理(图)

Mysql数据库大量删除操作及谈面向对象中的封装继承和多态原理(图)最近进行数据库操作,遇到一个问题,就是大量删除一个数据表中的数据后,由于设定了id是自增的,导致再插入时,默认生成的id会很大,这个时候想要再次插入新的数据,应该怎么办呢?1.明确目前最后一个id的大小select id from tags order by id DESC limit 0,1; 假设返回的是9,则设置数据表从10开始自增 2.修改这个数据表从10开始自增alter table tags auto_increme

java类的封装 继承 多态

1.猜数字小游戏 package cn.jiemoxiaodi_02; import java.util.Scanner; /** * 猜数字小游戏 * * @author huli * */ public class GuessNumberDemo { public static void main(String[] args) { int number = (int) (Math.random() * 100) + 1; while (true) { System.out.println("

JAVA的三大特征 封装继承多态- 简单总结

简单总结一下 封装-即从很多类的抽取相同的代码 写在一个类里. 好处是 代码的重用,安全. 继承-减少代码的书写. 其好处也是 代码的重用. 多态- 把不同的子类对象都当作父类来看,可以屏蔽不同子类对象之间的差异,写出通用的代码,做出通用的编程,以适应需求的不断变化. 总的来说还是接口的重用. 那么总结一下,JAVA的三大特征 其好处 就是代码与接口的重用. 封装可以隐藏实现细节,使得代码模块化: 继承可以扩展已存在的代码模块(类): 它们的目的都是为了——代码重用. 而多态则是为了实现另一个目

Java面向对象三大特性 封装 继承 多态

1.封装 封装的定义: 首先是抽象,把事物抽象成一个类,其次才是封装,将事物拥有的属性和动作隐藏起来,只保留特定的方法与外界联系 为什么需要封装: 封装符合面向对象设计原则的第一条:单一性原则,一个类把自己该做的事情封装起来,而不是暴露给其他类去处理,当内部的逻辑发生变化时,外部调用不用因此而修改,他们只调用开放的接口,而不用去关心内部的实现 举例: public class Human { private int age; private String name; public int get

面向对象:封装继承和多态、接口

1.多态 定义:不同对象对于同一个方法(Cut)调用表现出不同行为多态性主要是靠重写和隐藏来实现 a.(父类引用指向子类对象)b.(父类类型做参数,传递子类对象)自定义方法参数是父类类型 传递的实参是子类对象c.(父类类型作返回类型,return子类对象)自定义方法的返回类型是父类类型,return是类对象注:都是把子类对象赋给父类类型 举例: 添加乐器类using System;using System.Collections.Generic;using System.Linq;using S

四. Java继承和多态8.Java final关键字:阻止继承和多态

在 Java 中,声明类.变量和方法时,可使用关键字 final 来修饰.final 所修饰的数据具有"终态"的特征,表示"最终的"意思.具体规定如下: final 修饰的类不能被继承. final 修饰的方法不能被子类重写. final 修饰的变量(成员变量或局部变量)即成为常量,只能赋值一次. final 修饰的成员变量必须在声明的同时赋值,如果在声明的时候没有赋值,那么只有 一次赋值的机会,而且只能在构造方法中显式赋值,然后才能使用. final 修饰的局部变