Java基础-3（内部类，成员变量，时间相关类）

最新推荐文章于 2021-04-09 16:38:24 发布

机智电丁

最新推荐文章于 2021-04-09 16:38:24 发布

阅读量329

点赞数

分类专栏： Java基础

本文链接：https://blog.csdn.net/q172395505/article/details/107436626

版权

Java基础专栏收录该内容

11 篇文章 0 订阅

订阅专栏

18.内部类

如果一个事物的内部包含另一个事物，那么这就是一个类内部包含另一个类。
例如:身体和心脏的关系。又如:汽车和发动机的关系。

分类:

1.成员内部类

定义格式：
  成员内部类的定义格式:
  修饰符class 外部类名称{
  	修饰符class 内部类名称 {
  	//
  	//...
  	}
  }

注意：内用外，随意访问 ; 外用内，需要内部类对象。

public class Body { //外部类
	public class Heart { //成员内部类
		//内部类的方法
		public void beat(){
			System. out . println("心脏跳动:蹦蹦蹦! ");
			System. out . println("我叫:”+ name); //正确写法! 
		}
	}
	//外部类的成员变量
	private String name ;
	//外部类的方法
	public void methodBody() {
		System.out.println( "外部类的方法");
        new Heart().beat();
	}
	public String getName() {
		return name;
	}
	public void setName(String name) {
		this.name = name;
	}

此时生成的.class文件有两个，一个是“外部类名.class”和"外部类名$内部类名.class"，如上面的代码，生成的.class文件如下：

在这里插入图片描述

使用：

间接方式:在外部类的方法当中，使用内部类;然后main只是调用外部类的方法。

public class Demo01InnerClass {
	public static void main(String[] args) {
		Body body = new Body(); //外部类的对象
		//通过外部类的对象，调用外部类的方法，里面间接在使用内部类Heart
		body.methodBody();
	}
}

直接方式，公式:

正常类使用

	类名称  对象名= new  类名称();

而外部类则不同，如下;

外部类名称.内部类名称  对象名 = new  外部类名称().new内部类名称();

public class Demo01InnerClass {
	public static void main(String[] args) {
		//按照公式写:
		Body.Heart heart=new Body( ).new Heart( ) ;
		heart.beat();
	}
}

2.局部内部类(包含匿名内部类)

如果一个类是定义在一个方法内部的，那么这就是一个局部内部类。
“局部”:只有当前所属的方法才能使用它，出了这个方法外面就不能用了。

 定义格式:
修饰符class. 外部类名称{
	修饰符返回值类型外部类方法名称(参数列表) {
	class局部内部类名称{
	//
	}
}

public class Outer {
	public void method0uter( ) {
		class Inner { //局部内部类
			int num = 10;
			public void methodInner() {
				System. out . print1n(num); // 10
			}
		}
		Inner inner = new Inner();
		inner.methodInner();
	}
}

public class DemoMain {
	public static void main(String[] args) {
		Outer obj = new Outer();
		obj.method0uter( );
	}
}

类的权限修饰符(空即表示无法使用)

Y可修饰/N不可修饰	public>	protect>	(default)>	private
外部类	Y		Y
成员内部类	Y	Y	Y	Y
局部内部类	什么都不能写

内部类的同名变量访问

public class Outer {
	int num = 10; //外部类的成员变量
	public class Inner  {
		int num = 20; //内部类的成员变量
		public void methodInner() {
			int num = 30; //内部类方法的局部变量
			System.out.println(num); //局部变量，就近原则;
			System.out.println(this.num); //内部类的成员变量;
			System.out.println(Outer.this.num); //外部类的成员变量;
		}
	}
}

局部内部类的final问题

局部内部类，如果希望访问所在方法的局部变量，那么这个局部变量必须是有效final的。
备注:从Java 8+开始，只要局部变量事实不变，那么final关键字可以省略。

public class MyOuter {
	public void method0uter( ) {
		int num =10; //所在方法的局部变量
		class MyInner {
			public void methodInner( ) {
				System.out.println(num) ;
			}
		}
	}
}

原因:

new出来的对象在堆内存当中。
局部变量是跟着方法走的，在栈内存当中。
方法运行结束之后，立刻出栈，局部变量就会立刻消失。
但是new出来的对象会在堆当中持续存在，直到垃圾回收消失。

串联起来简单来说就是局部变量先是跟着方法一起在栈内存中创建产生，但是局部内部类的创建是通过new生成的，它是在堆内存中产生的，当内部类要使用方法的局部变量时，就会去栈中copy一份值放入常量池中，因此这个时候就需要局部变量默认为不可变的。

匿名内部类
- 如果接口的实现类(或者是父类的子类)只需要使用唯一的一次,那么这种情况下就可以省略掉该类的定义，而改为使用[匿名内部类]。
- 定义格式

匿名内部类的定义格式:

接口名称对象名= new 接口名称() {
   //覆盖重写所有抽象方法
}；

public interface MyInterface {
	void method();
}

pub1c class DemoMaini
	public static void main(String[] args) {
		//MyInterface obj = new MyInterfaceImpl();//实现类
		//obj.method();
		//MyInterface some = new MyInterface(); //错误写法!
		//使用匿名内部类
		MyInterface obj = new MyInterface() {
			@Override
            public void method( ) {
				System.out.print1n( "匿名内部类实现了方法! |");
			}
		};
    	obj.method();
	}
}

注意事项：

对格式"new接口名称() {…}"进行解析:

new代表创建对象的动作；
接口名称就是匿名内部类需要实现哪个接口；
**{…}**这才是匿名内部类的内容；

另外还要注意几点问题:
1.匿名内部类，在创建对象的时候，只能使用唯一一次。
如果希望多次创建对象，而且类的内容一样的话，那么就必须使用单独定义的实现类了。
2.匿名对象，在调用方法的时候，只能调用唯一一次。
如果希望同一个对象，调用多次方法，那么必须给对象起个名字。
3.匿名内部类是省略了实现类子类名称,但是匿名对象是省略了对象名称
强调:匿名内部类和匿名对象不是一回事! ! !

public class DemoMain {
	public static void main(String[ ] args) {
        
        MyInterface objA = new MyInterface() {
			@Override
			public void method1() {
				System.out.println("匿名内部类实现了方法! 111-A");
			}
			@Override
			public void method2() {
				System.out.println("匿名内部类实现了方法! 222-A");
			}
		};
		objA.method1() ;
		objA.method2() ;
		System.out.print1n("==============");

		//使用了匿名内部类，而且省略了对象名称，也是匿名对象
		new MyInterface() {
			@Override
			public void method1() {
				System. out . println("匿名内部类实现了方法! 111-B");
			}
			@Override
			public void method2() {
				System. out . println( "匿名内部类实现了方法! 222-B");
            }
		}.method1();
			//因为匿名对象无法调用第二次方法，所以需要再创建一个匿名内部类的匿名对象
		new MyInterface() {
			@Override
			public void method1() {
				System. out . println("匿名内部类实现了方法! 111-B");
			}
			@Override
			public void method2() {
				System. out . println( "匿名内部类实现了方法! 222-B");
            }
		}.method2();
	}
}

19.成员变量,返回值类型

成员变量

常见的基本数据类型可以作为成员变量
类可以成为成员变量，例如常用的String就是一个类
接口可以作为成员变量

public class Hero {
	private String name;
	//英雄的名称
	private Skill skill; //英雄的技能
	public Hero() {
    }
	public Hero(String name, Skill skill) {
		this.name = name ;
		this.skill = skill;
	}
	public void attack() {
		System.out.println("我叫"+ name + "，开始释放技能");
	}
    /*get和set方法避免篇幅暂时不写*/
}

public class SkillImpl implements Skill {
	@Override
	public void use( ) {
		System. out. println("Biu~biu~biu~") ;
	}
}

public class DemoGame {
	public static void main(String[] args) {
		Hero hero = new Hero();
		hero.setName("艾希"); //设置英雄的名称
        /*
		//设置英雄技能
		hero.setSkill(new SkillImp1());//使用单独定义的内部类
		*/
        /*
        //还可以改成使用匿名内部类
		Skill skill = new Skill() {
			@Override
			public void use() {
				System.out. println("Pia~pia~pia~");
			}
		};
		hero.setSkill(skill);
*/
        hero.setSkill(new skill(){
            @Override
			public void use() {
				System.out. println("Pia~biu~pia~biu~pia~");
			}
        });
		hero.attack();
}

返回值类型

基本数据类型，类都可以作为返回值类型
接口也可以作为返回值类型返回

/*
java. util.list正是ArrayL ist所实现的接口。
*/
public class DemoInterface {
	public static void main(String[] args) {
		//左边是接口名称，右边是实现类名称，这就是多态写法
		List<String> list = new ArrayList<>();
		List<String> result = addNames(list);
		for (int i = 0; i < result.size(); i++) {
			System.out.println(result.get(i));
		}
	public static List<String> addNames(List<String> list)
		list.add( "迪丽热巴");
		list.add("古力娜扎");
		list.add("玛尔扎哈");
		list.add("沙扬娜拉");
		return list;
	}
}

20.Object类

java. lang .object类是Java语言中的根类,即所有类的父类。它中描述的所有方法子类都可以使用。在对象实例化的时候,最终找的父类就是0bject。

如果一个类没有特别指定父类，那么默认则继承自Object类。例如:

public class MyClass /*extends object*/ {
	//...
}

toString方法

public class Person {
	private String name ;
	private int age;
	public Person() {
	}
	public Person(String nane, int age) {
		this. name = name ;
	this.age = age;
	}
    /*
    	直接打印对象的地址值没有意义,需要重写0bjec t类的tostring方法
		打印对象的属性(name, age)
    */
    @override
	public String toString() {
		return "Person{name=" +name+",age= "+age+"}";
	}//在idea环境中可以利用编辑器直接生成，格式与上面自写一致
    
    /*成员变量对应的set和get方法默认已有*/
}

/* 
java.lang.object类
类object是类层次结构的根(最顶层)类。每个类都使用object 作为超(父)类。
所有对象(包括数组)都实现这个类的方法。
*/
public class DemoToString {
	public static void main(String[] args) {
		/*
		Person类默认继承了0bject类,所以可以使用objec t类中的toString方法
		String tostring() 返回该对象的字符串表示。
		*/
		Person p = new Person( name: "张三E", age: 18);
		String s = p.toString();
		System.out.println(s);//打印地址
		//直接打印对象的名字，其实就是调用对象的tostring方法，p= p.toString()
		System.out.println(p) ;//也是打印地址，内容和S一样
  
        /*
			看一个类是否重写了tostring方法,直接打印这个类对应对象的名字即可
			如果没有重写tostring方法,那么打印的就是对象的地址值(默认)
			如果重写toString方法，那么就按照重写的方式打印
		*/
		Random r = new Random( );
		Random r = new Random( );
		System.out.println(r);//地址
        
		Scanner sc = new Scanner(System. in);
		System. out . println(sc);//实现了toString方法了，java.util.Scanner[del imiters=\p{javalhitespace}...
		
        ArrayList<Integer> list = new ArrayList<>();
		list.add(1);
		list.add(2);
		System.out.print1n(1ist);//[1, 2]
	}
}

equals方法

public class DemoEquals {
	public static void main(String[] args) {
		/*
			Person类默认继承了0bject类,所以可以使用object类的equals方法
			boolean equals(object obj) 指示其他某个对象是否与此对象“相等”。
			object类equals方法的源码:
			public boolean equals(Object obj) {
				return (this == obj);
			}
			参数:
				object obj: 可以传递任意的对象
			方法体：
				==:比较运算符,返回的就是一个布尔值true, false
				基本数据类型:比较的是值
				引用数据类型:比较的是两个对象的地址值
			this是谁?那个对象调用的方法,方法中的this就是那个对象;p1调用的equals方法,所以this就是p1
			obj是谁?传递过来的参数p
			this==obj --> p1==p2，因为两个的地址不一样，所以返回了false
		*/
		Person p1 = new Person( name: "迪丽热巴"，age;: 18);
		Person p2 = new Person( name: "古力娜扎"，age: 18);
		boolean b = p1 . equals(p2);
		System.out.println(b);//false
	}
}

object类的equal s方法默认比较的是两个对象的地址值,没有意义；正常情况下，我们需要将equals方法进行重写，让其比较的是属性值，不是地址。对象的属性值一样,返回true;否则返回false
问题:
隐含着一个多态
object obj = p2 = new Person(“古力娜扎”,18);

多态弊端:无法使用子类特有的内容(属性,方法)
解决:可以使用向下转型(强转)把object类型转换为Person
重写：

public class Person {
	/*其他部分不变，添加了equals方法*/
    
	@Override
	public boolean equals(object obj) {
		//使用向下转型 (强转)把objec t类型转换为Person
		Person p = (Person)obj;
		//比较两个对象的属性; -个是调用方法的this(p1), - -个就是p(obj=p2)
		boolean b = this .name. equals(p.name) && this. age==p.age;
		return b;
	}
}

public class DemoEquals {
	public static void main(String[] args) {
		Person p1 = new Person( name: "迪丽热巴"，age;: 18);
		Person p2 = new Person( name: "古力娜扎"，age: 18);
		boolean b = p1.equals(p2);
		System.out.println(b);//true
	}
}

因为原方法中，传参是Object 类型，所以传递可以传递任意类型的数据进去，如：

public class DemoEquals {
	public static void main(String[] args) {
		Person p1 = new Person( name: "迪丽热巴"，age;: 18);
		Random random=new Random();
		boolean b = p1.equals(random);//出现异常
		System.out.println(b);
	}
}

这样的话就会产生异常，因此还需要进行优化
另外的优化部分：
针对引用数据类型默认值为null的情况
传参就是自己本身的情况

public boolean equals(object obj) {
    //增加一个判断,传递的参数obj是this本身,直接返回true,提高程序效率
    if(obj==this){
        return true;
    }
    //增加一个判断,传递的参数obj是null,直接返回false,提高程序的效率
	if(obj==nu11){
		return false;
	}

	/*
	增加一个判断,是Person类型在转换，防止类型转换异常ClassCastException
	*/
	if(obj instanceof Person){
		//使用向下转型 (强转)把objec t类型转换为Person
		Person p = (Person)obj;
		//比较两个对象的属性; -个是调用方法的this(p1), - -个就是p(obj=p2)
		boolean b = this .name. equals(p.name) & this. age==p.age;
		return b;
    }
	//不是Person类型直接返回false
	return false;
}

idea提供快捷生成方法，具体生成方法如下：

/*IDEA默认的jdk版本*/
public boolean equals(0bject o) {
	if (this == o) return true;
	//getClass() != o. getClass()使用反射技术判断o是否为Person类型等效于obj instanceof Person
	if (o == null || getClass() != o.ge}.Class()) return false;
		Person person = (Person) o;
    
	if (age != person.age) return false;
	return name != null ? name.equals(person.name) : person.name = nul1;
}
/*jdk7+版本，较好*/
@override
public boolean equals(object 0) {
	if (this == 0) return true;
	if (o == null 11 getClass() != o.getClass()) return false;
		Person person = I(Person) o;
    
    //objects.equals(name, person.name)重点
	return age ==person.age &&
		objects.equals(name, person.name);
}

在JDK7添加了一个Objects工具类,它提供了一些方法来操作对象 ,它由一些静态的实用方法组成 ,这些方法是null-save (空指针安全的)或null-tolerant (容忍空指针的) , 用于计算对象的hashcode、返回对象的字符串表示形式、比较两个对象。
在比较两个对象的时候, Object的equals方法容易抛出空指针异常,而Objects类中的equals方法就优化了这个问
题。方法如下:
public static boolean equals(object a, object b) ;判断两个对象是否相等。
源码如下：

public static boolean equals(object a, object b) {
	return (a == b)|| (a != null && a.equals(b));
}

举例说明

public class Demo030bjects {
	public static void main(String[] args) {
		//String s1 = "abc"; 
		String s1 = null;
		String s2 = "abC";
		// b = s1.equals(s2);
		//System.out.print1n(b);//s1为null的时候，会出现空指针异常报错
        /*
        objects类的equals方法:对两个对象进行比较,防止空指针异常
			public static boolean equals(object a, object b) {
				return (a == b) I/ (Q != null && o.equals(b));
			}
		*/
		boolean b2 = objects . equals(S1, s2);
		System.out.println(b2);
	}
}

总结：

直接打印对象的时候，默认调用打印对象的toString方法；
toString方法：重写前：直接打印对象显示的是地址（包名类名@地址值）；重写后：打印的是对象中的属性值
equals方法：重写前：引用类型比较的是对象的地址值；重写后：比较对象的属性值
Objects是工具类，当用空对象去调用方法时，就会提示空指针异常，因此使用Objects的equals方法，可以有效避免空指针异常问题（前提，原类中的equals方法已经重写，否则空指针判断完还是会调用object的euqals方法，比较的还是地址）。

21.Date类

java.util.Date类表示特定的瞬间,精确到毫秒。
继续查阅Date类的描述,发现Date拥有多个构造函数,只是部分已经过时,但是其中有未过时的构造函数可以把毫秒值转成日期对象。
●public Date() :分配Date对象并初始化此对象,以表示分配它的时间(精确到毫秒)。
●public Date(long date) :分配Date对象并初始化此对象,以表示自从标准基准时间(称为“历元
( epoch )”,即1970年1月1日00:00:00 GMT )以来的指定毫秒数。

tips:由于我们处于东八区,所以我们的基准时间为1970年1月1日8时0分0秒。

简单来说:使用无参构造,可以自动设置当前系统时间的毫秒时刻;指定long类型的构造参数,可以自定义毫秒
时刻。

/*
毫秒值的作用:可以对时间和日期进行计算
2099-01-03到2088-01-01 中间-共有多少天
可以日期转换为毫秒进行计算,计算完毕，在把毫秒转换为日期
把日期转换为毫秒:
当前的日期:2088-01-01
时间原点(0毫秒):1970年1月1日00:00:00(英国格林威治)
就是计算当前日期到时间原点之间一共经历了多少毫秒(3742767540068L)
把毫秒转换为日期:
1天=24x60x60=86400秒= 86400 x 1000 = 86400000毫秒
*/
public class Demo01Date {
	public static void main(String[] args) {
		System.out.println(System.currentTimeMillis());//获取当前系统时间到1970年1月1日00:00:00经历了多少毫秒
	}
}

public class Demo02Date {
	public static void main(String[] args) {
		demo02();
	}
    /*
	Date类的成员方法
	long getTime() 把日期转换为毫秒(相当于System.currentTimeMillis())
	返回自1970 年1月1日00:00:00 GMT以来此Date对象表示的毫秒数。
	*/
	private static void demo03() {
		Date date = new Date();
		long time = date.getTime();
		System.out.println(time);   
    }

	/*
	Date类的带参数构造方法:
	Date(long date) :传递毫秒值,把毫秒转换为Date日期
	*/
	private static void demo02(){
		Date d1 = new Date(OL);
		System.out.print1n(d1);//Thu Jan 01 08:00:00 CST 1970
		Date d2=new Date (158111111111L);
		System. out .print1n(d2);//Sun Jan 05 07:45:11 CST 1975 
	}
	/*
	Date类的空参数构造方法:
	Date()获取的就是当前系统的日期和时间
	*/
	private static void demo01(){
		Date date = new Date();
		System.out.println(date);
	}
}

22.DataFormat类

java. text . DateFormat是日期/时间格式化子类的抽象类,我们通过这个类可以帮我们完成日期和文本之间的转换,也就是可以在Date对象与String对象之间进行来回转换。

格式化:按照指定的格式,从Date对象转换为String对象。
解析:按照指定的格式,从String对象转换为Date对象。

构造方法

由于DateFormat为抽象类,不能直接使用,所以需要常用的子类java. text. SimpleDateFormat.这个类需要一个模式(格式)来指定格式化或解析的标准。构造方法为:
●public SimpleDateFormat(String pattern):用给定的模式和默认语言环境的日期格式符号构造SimpleDateFormat。
参数pattern是一个字符串,代表日期时间的自定义格式。

格式规则

标识字母（区分大小写）	含义
y	年
M	月
d	日
H	时
m	分
s	秒

/*
java. text . DateFormat :是日期/时间格式化子类的抽象类
作用:
	格式化(也就是日期->文本)、解析(文本->日期)
成员方法:
	String format(Date date)按照指定的模式， 把Date日期，格式化为符合模式的字符串
	Date parse(String. source) 把符合模式的字符串，解析为Date日期
DateFormat类是一个抽象类,无法直接创建对象使用，可以使用DateFormat的子类

java.text.simpleDateFormat extends DateFormat
构造方法:
	SimpleDateFormat(String pattern)用给定的模式和默认语言环境的E日期格式符号构造SimpleDateFormato
	参数：
		String pattern：传递指定的模式
	模式：区分大小写，具体看上表
	写对应的模式，会把模式替换为对应的日期时间
		"yyyy-MM-dd HH:mm:ss"
		"yyyy年MM月dd日 HH时mm分ss秒”
	注意:
	模式中的字母不能更改,连接模式的符号可以改变
*/
public Class Demo01DateFormat {
    public static void main(String[] args) throws ParseException{
		//demo01();
        //
	}
	/*
	使用DateFormat类中的方法format ,把日期格式化为文本
	String format(Date date)按照指定的模式， 把Date日期，格式化为符合模式的字符串
	使用步骤:
		1.创建SimpleDateFormat对象,构造方法中传递指定的模式
		2.调用SimpleDateFormat对象中的方法format,按照构造方法中指定的模式,把Date日期格式化为符合模式的字符串(文本)
		*/
	private static void demo01(){
		//1 .创建SimpleDateFormat对象，构造方法中传递指定的模式
		SimpleDateFormat sdf =new SimpleDateFormat( pattern: "yyyy- M-dd HH:mm:ss");
		//2.调用SimpleDateFormat对象中的方法format,按照构造方法中指定的模式，把Date日期格式化为符合模式的字符串(文本)
		Date date = new Date();
		String text = sdf . format(date); 
		System.out.println(date);//英文日期
		System.out.println(text);//正常显示日期
    }
    
    /*
	使用DateFormat类中的方法parse,把文本解析为日期
	Date parse(String source) 把符合模式的字符串,解析为Date日期
	使用步骤:
		1.创建SimpleDateFormat对象,构造方法中传递指定的模式
		2.调用SimpleDateFormat对象中的方法parse,把符合构造方法中模式的字符串,解析为Date日期
	注意:
	public Date parse(String source) throws ParseException
	parse方法声明了一个异常叫ParseExcept ion解析异常
	如果字符串和构造方法中的模式不一样,那么程序就会抛出此异常
	调用一个抛出了异常的方法，就必须的处理这个异常,要么throws继续声明抛出这一个异常, 要么try... catch自己处理这个异常
	*/
	private static void demo02() throws ParseException{
		//1 .创建SimpleDateFormat对象,构造方法中传递指定的模式
		SimpleDateFormat sdf = new SimpleDateFormat(pattern: "yyyy年MM月dd日HH时 mm分ss秒");
		//2.调用SimpleDateFormat对象中的方法parse,把符合构造方法中模式的字符串,解析为Date日期
		Date date = sdf.parse(source: "2088年08月08日17时01分10秒");
		System.out.println(date);
    }
}

举例运用

public class Demo02Test {
	public static void main(String[] args) throws ParseException {
		//1.使用Scanner类中的方法next,获取出生日期
		Scanner sc = new Scanner(System. in);
		System.out.println( "请输入您得到出生日期,格式为yyyy-MM-dd");
		String birthdayDateString = sc.next();
		
		//2.使用DateFormat类中的方法parse,把字符串的出生日期解析为Date格式
		SimpleDateFormat sdf = new SimpleDateFormat( pattern: "yyyy-MM-dd");
		Date birthdayDate = sdf.parse(birthdayDateString);
		
		//3.把Date格式的出生日期转换为毫秒值
		long birthdayDateTime = bi rthdayDate.getTime();
		
		//4.获取当前的日期，转换为毫秒值
		long todayTime = new Date() . getTime();
		
		//5.使用当前日期的毫秒值-出生日期的毫秒值
		long time = todayTime- birthdayDateTime;
		
		//6.把毫秒值的差值转换为天(s/1000/60/60/24)
		System.out.println(time/ 1000/60/60/24);
	}
}

23.Calender类

java .util.calendar是日历类,在Date后出现,替换掉了许多Date的右法。该类将所有可能用到的时间信息封装为静态成员变量,方便获取。日历类就是方便获取各个时间属性的。

/*
java.util.Calendar类:日历类
Calendar类是一个抽象类,里边提供了很多操作日历字段的方法(YEAR、MONTH、DAY_ OF_ MONTH、HOUR )
Calendar类无法直接创建对象使用,里边有一个静态方法叫getInstance(),该方法返回了Calendar类的子类对象
static calendar getInstance() 使用默认时区和语言环境获得一个日历。
*/
public Class Demo01Calendar {
	public static void main(String[] args) {
		Calendar C = Calendar.getInstance();//多态
		System.out.println(c);
	}
}

常用方法

根据Calendar类的API文档,常用方法有:

public int get(int field): 返回给定日历字段的值。
public void set(int field, int value) :将给定的日历字段设置为给定值。
public abstract void add(int field, int amount): 根据日历的规则，为给定的日历字段添加或减去指定的时间量。
public Date getTime() :返回一个表示此Calendar时间值(从历元到现在的毫秒偏移量)的Date对象。

Calendar类中提供很多成员常量,代表给定的日历字段:

字段值	含义
YEAR	年
MONTH	月（从0开始，可以+1使用）
DAY_OF_MONTH	月中的天（几号）
HOUR	时（12小时制）
HOUR_OF_DAY	时（24小时制）
MINUTE	分
SECOND	秒

/*
Calendar类的成员方法:
	- public int get(int field): 返回给定日历字段的值。
	- public void set(int field, int value): 将给定的日历字段设置为给定值。
	- public abstract void add(int field, int amount): 根据日历的规则，为给定的日历字段添加或减去指定的时间量。
	- public Date getTime(): 返回一个表示此Calendar时间值(从历元到现在的毫秒偏移量)的Date对象。
成员方法的参数: 
	int field:日历类的字段，可以使用Calendar类的静态成员变量获取
	public static final int YEAR = 1;年
	public static final int MONTH = 2;月
	public static final int DATE = 5;月中的某一天
	public static final int DAY_OF_MONTH = 5;月中的某一天
	public static final int HOUR = 10;时
	public static final int MINUTE = 12;分
	public static final int SECOND = 13;秒
*/
public Class Demo02Calendar {
	public static void main(String[] args) {
		//demo01();
        //demo02();
        //demo03();
        //demo04();
	}
    public void show(Calendar c){
        int year = c.get(Calendar.YEAR);
		System.out.println(year);
        
		int month = c.get(Calendar.MONTH);
		System.out.println(month+1) ;//西方的月份0-11东方:1-12
        
		//int date = c.get(Calendar.DATE);
        int date = c.get(Calendar.DAY_OF_MONTH);
		System.out.println(date);
    }
    /*
	public int get(int field): 返回给定日历字段的值。
	参数:传递指定的日历字段(YEAR, MONTH...)
	返回值:日历字段代表具体的值
	*/
	private static void demoe1() {
		//使用getInstance方法获取Calendar对象
		Calendar c = Calendar.getInstance();
        show(c);
	}

    /*
	public void set(int field, int value):
	将给定的日历字段设置为给定值。
	参数:
	int field:传递指定的日历字段( YEAR, MONTH...)
	int value :传递的字段设置的具体的值
	*/
	private static void demo02() {
		//使用getInstance方法获取Calendar对象
		Calendar c = Calendar . getInstance();
		//设置年为9999
		c.set(Calendar. YEAR, 9999);
        //设置月为9
		c.set(Calendar.MONTH,9);
		//设置日9
		c.set(Calendar.DATE,9);

		//同时设置年月日，可以使用set的重载方法
		c.set(8888,8,8);

         show(c);
    }
    
    /*
	public abstract void add(int field, int amount): 根据日历的规则，为给定的日历字段添加或减去指定的时间量。
	把指定的字段增加/减少指定的值
	参数:
		int field:传递指定的日历字段(YEAR, MONTH...)
		int amount :增加/减少的值
			正数:增加
			负数:减少
		*/
	private static void demo03() {
		//使用getInstance方法获取Calendar对象
		Calendar c = Calendar .getInstance();
		//把年增加2年
		C.add( Calendar.YEAR, amount: 2);
		//把月减少3个月
		C.add(Calendar.MONTH, amount: -3);
        
		show(c);
    }
    /*
	public Date getTime(): 返回一个表示此calendar时间值(从历元到现在的毫秒偏移量)的Date对象。
	把日历对象，转换为日期对象
	*/
	private static void demo04() {
		//使用getInstance方法获取Calendar对象
		Calendar C = Calendar. getInstance();|
		Date date = c.getTime();
		System. out. println(date);
	}
}

小结

1.Date类

A.构造方法

Date();根据当前系统时间创建 日期对象
Date(long time);根据传入的毫秒值时间创建日期对象

B.成员方法

long getTime();获取当前日期对象的毫秒值时间
String toLocaleString0;根据本地格式转换日期对象

2.DateFormat类&SimpleDateFormat类

A.构造方法

SimpleDateFormat(Strings);根据指定模板创建 日期格式化对象

B.成员方法

String format(Date d);根据指定格式格式化日期对象
Date parse(tring S);根据指定格式解析字符串

public class Test01 {
	public static void main(String[ ] args) throws ParseException {
		//空参构造方法
		Date d = new Date(3000L);
		System.out.println(d.toLoealeString()); // 1970-1-1 8:00:03
		//创建日期格式化对象
		SimpleDateFormat sdf = new SimpleDateFormat( pattern: "yyy年MM月dd日HH:mm:ss");
		String format = sdf . format(d);
		System. out.println(format); // 1970年01月01日08:00:03
		String str = "2088年08月08日08:08:08"; 
		Date parse = sdf.parse(str);
		System.out.println(parse);
    }
}

3.Calendar类

A.创建对象方式

Calendar C = Calendar.newlnstance);获取日历类对象

B.成员方法

int get(int n);获取指定日历字段信息
void set(int n,int value);将指定日历字段设置为指定的值
void add(int n,int value);将指定日 历字段增加或减少指定的值

public class Test02 {
	public static void main(String[] args) {
		//获取日历类对象
		Calendar c = Calendar.getInstance();
		//get方法
		int year = c.get(Calendar.YEAR);
		System.out.println(year);
		int month = c.get(Calendar.MONTH)+1;
		System.out.println( month);
		system.out.print1n("---------");
		//set方法
		C. set(calendar.YEAR, 2088) ;
		year = C. get(Calendar . YEAR);
		System.out.println(year);
		System.out.println("----------");
		//add方法
		c.add(Calendar.YEAR, 2);
		year = c.get(Calendar.YEAR);
		System.out.println(year);
	}
}