Java入门第三篇

最新推荐文章于 2024-10-08 22:49:36 发布

zhtasd123

最新推荐文章于 2024-10-08 22:49:36 发布

阅读量343

点赞数

CC 4.0 BY-SA版权

文章标签：抽象类多态

本文链接：https://blog.youkuaiyun.com/zhtasd123/article/details/108033296

本文深入探讨Java面向对象的高级特性，包括final关键字、static关键字、多态性、抽象类、接口等概念，以及它们的语法、特点和应用场景，通过实例代码帮助读者理解面向对象的精髓。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

10.final关键字：代表最终的意思

可以修饰什么？
1.修饰类
2.修饰方法
3.修饰成员变量
4.修饰局部变量
修饰类，这个类有什么特点？
这个类不能被继承，他就是一个太监类，但是可以继承别的类
修饰方法，这个方法有什么特点？
代表这个方法是一个最终方法，不能被重写
修改成员变量有什么特点？成员变量的值不可改变
1.成员变量不会再有默认值
2.如果使用final关键字，必须直接对成员变量进行赋值
修饰局部变量的特点。局部变量的值不能改变,一般用它修饰一个常量
public class Person {

private String name;
private final String sex=“男”;

public String getName() {
return name;
}

public void setName(String name) {
this.name = name;
}

public String getSex() {
return sex;
}

public final void eat(){
System.out.println(“吃饭”);
}

@Override
public String toString() {
return “Person [name=” + name + “, sex=” + sex + “]”;
}

}

public class TestPerson {

public static void main(String[] args) {
	Person p=new Person();
	p.setName("小明");
	System.out.println(p.toString());
	
	final int num=10;
	//num=20;
	System.out.println(num);
	
	final int A;
	A=10;
	//A=12;
}

}

11.static关键字 :静态的（重点）

1.static修饰成员变量（类变量）
（1）.修饰成员变量，这个变量就不属于对象了，而属于类本身，我们就可以通过"类名.属性名"
(2).只要通过我这个类创建的对象，这些对象都可以共享这个属性
(3).当其中一个对象对类变量进行更改以后，其他对象的这个类变量也会更改，
VS实例变量（非static的变量，属于对象本身，各个对象都各自有一套副本）
(4).类变量是随着类的加载而加载，类变量的生命周期大于实例变量
(5),类变量放在方法区的静态域里面
2.static修饰方法(类方法)
(1).修饰方法，这个方法就属于类本身了，我可以通过"类名.方法名()"进行调用
(2).随着类而加载
(3).在静态方法里面只能调用静态变量和静态方法，相反在普通放里面可以调用静态方法和静态变量，因为静态方法或静态变量
加载时机早于实例变量和实例方法的加载时机
(4).不能使用this和supper关键字
3.static修饰代码块
代码块的作用完成初始化
（1）非静态代码块：
可以给类的属性进行初始化操作,同时还可以调用类的方法(静态的，非静态的)；
里面可以有输出语句
每创建完一个对象，非静态代码块就加载一次
（2）静态代码块
里面可以有输出语句
随着类加载而加载，只会执行一次
静态代码的加载时机早于非静态代码块
静态代码块里面只能调用类变量和类方法
作用：jdbc 驱动用户名密码数据库的连接地址
对属性赋值：（1）默认初始化 (2)显示的初始化 (3)通过set方法或者构造方法 (4)代码块
public class SportsMan {

//实例变量
private String name;
private int age;
//类变量
static String nation=“中国”;
//代码块：初始化
{
name=“张三”;
age=12;
show();
show1();
nation=“1”;
System.out.println(“非静态的代码块”);

}
//前面加一个static就是一个静态代码块
static{
// name=“李四”;
// show();
show1();
System.out.println(“这是一个静态代码块”);
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}

public String getNation() {
return nation;
}
public void setNation(String nation) {
this.nation = nation;
}
public SportsMan(String name, int age) {
super();
this.name = name;
this.age = age;
}
public SportsMan() {
super();
}
@Override
public String toString() {
return “SportsMan [name=” + name + “, age=” + age + “, nation=” + nation + “]”;
}

//普通方法
public void show(){//加载时机晚
// System.out.println(this.age);
// System.out.println(nation);
// show1();
System.out.println(“这是一个普通方法”);
}

//静态方法
public static void show1(){//加载的时机早
// //this代表当前对象
// System.out.println(nation);
// //show();
System.out.println(“这是一个静态方法”);
}

}
*********************************************************************public class TestSportsMan {

public static void main(String[] args) {
	SportsMan s1=new SportsMan("老王", 35);
	SportsMan s2=new SportsMan("老李", 32);
	s1.setNation("中国");
	SportsMan.nation="china";
	s1.show();
	SportsMan.show1();
	
	System.out.println(s1);
	System.out.println(s2);
}

}
12.面向对象的第三个特性：多态性
1.什么是多态性？

(1)同一个动作与不同的对象产生不同的行为
(2)多态指的是一个对象的多种形态
2.多态的体现方式
（1）.使用继承：不同的子类重写父类方法后，体现出来的形式不一样
(2)接口的实现
3.形成多态的必要条件
(1)继承：存在子类和父类的关系
(2)接口实现：定义一个类实现对应的接口
(3)重写：子类重写了父类的方法
(4)重载：调用相同的方法名，实现的功能时不一样
（5）.子类对象的多态性（重点）：父类的引用指向子类的实例
4.程序分为两种状态，一个编译状态，一个是运行状态
对于多态来说，编译时看左边，你这个对象是定义的是什么类型就是什么类型，讲pet对象看做是Pet类型
运行时，看右边，真正执行的对象，也就是子类对象(Dog),执行的也是子类重写后的方法。
5.上转型和下转型
(1)上转型：讲子类对象交给父类引用，可以自动转换
(2)下转型：把父类转成子类强制类型转换
6.对象的多态性
(1).父类的引用指向子类的实例
(2).在编译期间调用的父类的方法，真正执行的时候，执行的是子类的方法

(3).编译看左边，运行看右边
public class Test {

public static void main(String[] args) {

 //创建宠物对象
 Pet p=new Pet("宠物");
 p.eat();
 p.info();
 
 //狗类对象
 Dog dog=new Dog("小金", "金毛");
 dog.eat();
 dog.info();
 
 //创建企鹅对象
 Penguin pe=new Penguin("Q妹", "女");
 pe.eat();
 pe.info();
 
 //创建主人对象
 Master m=new Master();
 //调用喂食的方法
 m.feed(dog);
 m.feed(pe);
 System.out.println("=============================================");
 //子类对象的多态性，父类的引用指向子类的实例
 Pet pet=new Dog("小迪", "泰迪");//安全性更高  向上转型
 pet.info();//
 //父类对象可以调用狗类独有的方法吗？不可以
 //在编译期间，程序会把pet对象看成是父类对象，而父类方法没有sleep()方法
 //pet.sleep();
 
 //现在我就想通过pet去调用sleep()方法？ 强制类型转换
 //short转成int，自动类型转换，int转成short,得强制类型换行
 //把父类转成子类同一个道理
 Dog dog1=(Dog)pet;//向下转型
 dog1.sleep();
 
 //pet前面已经转成了dog，现在相当于把dog转成企鹅

// Penguin pe1=(Penguin)pet;
// pe1.swimming();
//instanceof:用于判断类型是否匹配
if(pet instanceof Dog){//判断父类pet是否属于子类对象Dog的实例
Dog dog2=(Dog)pet;
dog2.sleep();
}else if(pet instanceof Penguin){
Penguin pe1=(Penguin)pet;
pe1.swimming();
}

System.out.println("================================================");
	Pet dog2=new Dog("小花","哈士奇");
	Pet pe1=new Penguin("小黑", "男");
	Master m1=new Master();
	m1.play(dog2);//接飞盘
	m1.play(pe1);//游泳
}

}

//宠物类
public class Pet {

private String name;//昵称
protected int health=100;//健康值
protected int love=0;//亲密的


public int getLove() {
	return love;
}
public void setLove(int love) {
	this.love = love;
}
public String getName() {
	return name;
}
public void setName(String name) {
	this.name = name;
}
public int getHealth() {
	return health;
}
public void setHealth(int health) {
	this.health = health;
}
public Pet(String name, int health) {
	super();
	this.name = name;
	this.health = health;
}


public Pet(String name) {
	super();
	this.name = name;
}
public Pet() {
	super();
}


//吃食
public void eat(){
	System.out.println("宠物吃食");
}

//打印宠物信息
public void info(){
	System.out.println("名字叫："+this.name+",我的健康值是："+this.health+",我和主人的亲密度："+this.love);
}

}

//狗类
public class Dog extends Pet {

private String starin;//品种

public String getStarin() {
	return starin;
}

public void setStarin(String starin) {
	this.starin = starin;
}

public Dog() {
	super();
}

public Dog(String name, String starin) {
	super(name);
	this.starin = starin;
}

//重写吃饭的方法
public void eat(){
	super.health=super.health+3;//吃饱以后健康值加3
	System.out.println("狗狗吃饱了，健康值加3");
}

//重写输出的方法
public void info(){
	super.info();//调用父类未重写前的方法
	System.out.println("我的品种是："+this.starin);
}

public void sleep(){
	System.out.println("狗狗在呼呼大睡");
}

//接飞盘
public void catchingFlyDisc(){
	System.out.println("狗狗正在接飞盘：");
	super.love=super.love+5;
	super.health-=10;
}

}

//企鹅类
public class Penguin extends Pet{

private String sex;//性别

public String getSex() {
	return sex;
}

public void setSex(String sex) {
	this.sex = sex;
}

public Penguin() {
	super();
}

public Penguin(String name,String sex) {
	super(name);
	this.sex = sex;
	
}

//重写吃饭的方法
public void eat(){
	super.health=super.health+5;
	System.out.println("企鹅吃饱了，健康值加5");
}

//重写输出的方法
public void info(){
	super.info();
	System.out.println(",我的性别是："+this.sex);
}

//游泳
public void swimming(){
	System.out.println("企鹅正在游泳：");
	super.love=super.love+5;
	super.health-=10;
}

}

//主人类
public class Master {

private String hostName;//主人姓名

public String getHostName() {
	return hostName;
}

public void setHostName(String hostName) {
	this.hostName = hostName;
}

//给狗狗喂食
public void feed(Dog dog){
	dog.eat();
}

//给企鹅喂食
public void feed(Penguin p){
	p.eat();
}

//玩游戏
public void play(Pet pet){
	if(pet instanceof Dog){
		Dog dog=(Dog)pet;
		dog.catchingFlyDisc();
		dog.info();
		
	}else if(pet instanceof Penguin){
		Penguin p=(Penguin)pet;
		p.swimming();
		p.info();
	}
	
}

}
13.抽象类：

1.什么是抽象类？
如果一个类表达的是一种抽象的概念，仅仅作为其他派生类的一个父类，主要功能的定义，具体的实现交给他的子类来做.
2.语法
在class前面加上abstract就是一个抽象类
3.抽象类的特点：
（1）.抽象方法所在的类必须是抽象类
(2).抽象类不能进行实例化
(3).如果要实现一个抽象类，创建一个子类去继承这个抽象类
(4).子类继承抽象类以后，必须重写抽象类里面所有的抽象方法(前提子类不是抽象类)
(5).抽象类里面可以定义普通方法
(6).抽象类可以定义构造方法
抽象方法：
在返回值前面加上abstract就是一个抽象方法
抽象方法的特点：
只能方法的定义，没有方法体
//动物类
public abstract class Animal {

private String name;

//动物吃什么？因为动物吃什么这就是一个抽象的，因为我也不知道是什么动物
public abstract void eat();

public void walk(){
System.out.println("…");
}

public Animal(){

}

public Animal(String name){
this.name=name;
}

}

//猫类
public class Cat extends Animal {

@Override
public void eat() {
	System.out.println("猫爱吃鱼");
	
}

}

//狗类
public abstract class Dog extends Animal {

//抽象方法
public abstract void sleep();

public Dog(String name){
	super(name);
}

public Dog(){
	
}

}

//二哈类
public class Dog2Ha extends Dog {

@Override
public void sleep() {
	System.out.println("二哈呼呼大睡");
	
}

@Override
public void eat() {
	System.out.println("二哈吃狗粮");
	
}

}

public class TestAnimal {

public static void main(String[] args) {
	
	//Animal an=new Animal();因为动物也是一个抽象的，不具体的
	
	//多态：父类的引用指向了子类

// Animal dog=new Dog();
// dog.eat();

	Animal cat=new Cat();
	cat.eat();
	
	Dog dog=new Dog2Ha();
	dog.eat();
	dog.sleep();

}

}
13.接口
1.什么是接口？

(1).就是多个类之间的公共规范
(2)接口就是一个特殊的抽象类，接口里面的方法都是抽象方法
(3).接口解决了java单继承的鸡肋
2.怎么定义一个接口
public interface 接口名{
}

*3.接口的特点
*(1)接口里面的属性都是常量，默认会给你加上“public static final”修饰
*(2)接口里面的方法都是抽象方法，默认会给你加上“public abstract”进行修饰
*(3)接口不能够实例化。
*(4)抽象类是继承，接口是用来实现的
*(5)一个类实现一个接口，必须实现这个接口里面所有的抽象方法(前提这个类不是抽象类)
*(6)一个类可以实现多个接口，中间使用逗号隔开
*(7)接口里面不能定义普通方法
*(8)接口没有构造方法
*(9)接口也可以继承接口,并且可以继承多个接口
*
*4.实现类
*(1)实现接口的类叫做实现类 class A implements B
*(2)如果一个类继承了一个父类同时需要实现一个接口，继承一定是在实现接口前面

class E extends D implements C

//交通工具类
public interface Traffic {

// int age=10;//常量
// public static final int Age1=10;

public abstract  void start();//这是一个抽象方法

abstract void add();//这也是一个重新方法

public void run();//这是一个抽象方法

 void stop();//这也是一个抽象方法

// public void method(){
//
// }
//

}

//针对于加油交通工具的接口
public interface Oil {

void addOil();//加油

}

//汽车类
public class Car implements Traffic,Oil {

@Override
public void start() {
	System.out.println("汽车启动了....");
	
}

@Override
public void add() {
    System.out.println("汽车加速了....");
	
}

@Override
public void run() {
	System.out.println("汽车开始跑了........");
	
}

@Override
public void stop() {
	System.out.println("汽车停止了...........");
	
}

@Override
public void addOil() {
	System.out.println("汽车加油...........");
	
}

}

//电动汽车类
public class Evs implements Traffic {

@Override
public void start() {
	System.out.println("电动汽车启动了.......");
	
}

@Override
public void add() {
	System.out.println("电动汽车加速了........");
	
}

@Override
public void run() {
	System.out.println("电动汽车开始跑了.......");
	
}

@Override
public void stop() {
	System.out.println("电动汽车停止了............");
	
}

public class TestTraffic {

public static void main(String[] args) {

// Traffic t=new Traffic();

	//多态:接口的引用指向实现类的实例
	Traffic car=new Car();
	car.start();
	car.add();
	car.run();
	car.stop();
	
	//电动汽车
	Traffic evs=new Evs();
	evs.add();
	evs.start();
	evs.run();
	evs.stop();

}

}

}
14.实例
(1)播放器类
public abstract class Player {

//播放的方法
public abstract void play(String file);

//停止
public void stop(){
	System.out.println("播放停止.....");
}

}

public class AVI extends Player {

@Override
public void play(String file) {
	System.out.println("播放"+file+"视频......");
	
}

}

public class MP4 extends Player{

@Override
public void play(String file) {
	System.out.println("播放"+file+"视频.....");
	
}

}

public class RMVB extends Player {

@Override
public void play(String file) {
	System.out.println("播放"+file+"视频......");
	
}

}

public class WMN extends Player {

@Override
public void play(String file) {
	System.out.println("播放"+file+"视频......");
	
}

}

public class TestPlayer {

public static void main(String[] args) {
	
	//1.视频文件
	String file="海王.mp4";
	//2.获取视频文件的扩展名
	//lastIndexOf():获取最后字符.的下标
	int index=file.lastIndexOf(".");
	//3.截取字符串，只保留扩展名
	String str=file.substring(index+1);
	Player player=null;
	switch (str.toUpperCase()) {//把字母变成大写
	case "MP4":
		player=new MP4();
		break;
	case "AVI":
		player=new AVI();
		break;
	case "WMN":
		player=new WMN();
		break;
	case "RMVB":
		player=new RMVB();
		break;
	default:
		System.out.println("不支持此格式视频....");
		break;
	}
	System.out.println("开始播放视频...........");
	//调用播放视频的方法
	player.play(file);
	
	//休眠5秒
	try {
		Thread.sleep(5000);
	} catch (InterruptedException e) {
		// TODO Auto-generated catch block
		e.printStackTrace();
	}
	
	//停止播放
	player.stop();

}

}
(2)实现两个对象的比较
public class ComparableCircle extends Circle implements CompareObject {

public ComparableCircle(double r){
	super(r);
}

//实现两个对象的比较
@Override
public int compareTo(Object o) {//o传过来的实参c2
	ComparableCircle c2=(ComparableCircle) o;//向下转型
	if(this.getRadius()>c2.getRadius()){//this代表当前对象，c1
		return 1;//代表当前对象大
	}else if(this.getRadius()<c2.getRadius()){
		return -1;//代表当前对象小
	}else{
		return 0;
	}
	
}

}

public interface CompareObject {

//比较两个对象
public int compareTo(Object o);

}

public class Circle {

private double radius;//半径

public Circle(double radius) {
	super();
	this.radius = radius;
}

public Circle() {
	super();
}

public double getRadius() {
	return radius;
}

public void setRadius(double radius) {
	this.radius = radius;
}

}

public class TestInterface {
public static void main(String[] args) {

	//创建两个对象
	ComparableCircle c1=new ComparableCircle(5);
	ComparableCircle c2=new ComparableCircle(4);
	int result=c1.compareTo(c2);
	System.out.println(result);
}

}

(3)电脑USB接口
public class Computer {

//电脑开机
public void poweron(){
	System.out.println("电脑开机.....");
}

//电脑关机
public void poweroff(){
	System.out.println("电脑关机.....");
}

//电脑使用usb接口
public void use(USB usb){
	//1.打开usb接口
	usb.open();
	//判断usb接口插入是键盘还是鼠标
	if(usb instanceof Mouse){
		Mouse mouse=(Mouse)usb;
		mouse.click();
		mouse.doubleClick();
	}else if(usb instanceof KeyBoard){
		KeyBoard kb=(KeyBoard)usb;
		kb.input();
		
	}
	
	//2.关闭usb接口
	usb.close();
	
}

}

//usb接口
public interface USB {

//打开USB
void open();

//关闭USB
void close();

}

//键盘类
public class KeyBoard implements USB {

@Override
public void open() {
	System.out.println("打开键盘.....");
	
}

@Override
public void close() {
	System.out.println("关闭键盘......");
	
}

public void input(){
	System.out.println("键盘输入.......");
}

}

//鼠标类
public class Mouse implements USB {

@Override
public void open() {
	System.out.println("打开鼠标....");
	
}

@Override
public void close() {
	System.out.println("关闭鼠标...");
	
}

public void click(){
	System.out.println("单击操作.....");
}

public void doubleClick(){
	System.out.println("双击操作......");
}

}

public class TestComputer {

public static void main(String[] args) {
	
	//创建电脑对象
	Computer computer=new Computer();
	//电脑开机
	computer.poweron();
	//执行usb的操作
	USB mouse=new Mouse();//创建鼠标对象
	USB keyBoard=new KeyBoard();//创建键盘对象
	computer.use(mouse);
	
	//电脑关机
	computer.poweroff();

}

}

十四、常用类

1.stringbuffer类演示
public class Demo1 {
public static void main(String[] args) {
//
StringBuffer sb = new StringBuffer();
// select * from tb_user where id = ‘123’ and name = ‘zhang’
String id = args[0];
String name = args[1];
sb.append(" select * from tb_user “);
sb.append(” where id = ‘");
sb.append(id);
sb.append("’ and name = ‘");
sb.append(name);
sb.append("’ ");
System.out.println(sb);

	// 拼接json数据  【｛“id”：“123”，“name”：“zhangsan”｝，｛“id”：“123”，“name”：“zhangsan”｝】
	Person[] ps = new Person[3];
	Person p1 = new Person();
	p1.id = 1;
	p1.name = "zhangs1";
	Person p2 = new Person();
	p2.id = 2;
	p2.name = "zhangs2";
	Person p3 = new Person();
	p3.id = 3;
	p3.name = "zhangs3";
	ps[0] = p1;
	ps[1] = p2;
	ps[2] = p3;
	
	StringBuffer sbf = new StringBuffer();
	sbf.append("[");
	for (int i = 0; i < ps.length; i++) {
		Person p = ps[i];
		//【｛“id”：123，“name”：“zhangsan”｝，｛“id”：.。。。。。】
		sbf.append("{\"id\":");
		sbf.append(p.id);
		sbf.append(",\"name\":\"");
		sbf.append(p.name+"\"},"); // 
	}
	// [{"id":1,"name":"zhangs1"},{"id":2,"name":"zhangs2"},{"id":3,"name":"zhangs3"},
	sbf.deleteCharAt(sbf.length() - 1);
	sbf.append("]");
	System.out.println(sbf.toString());
	int a = 1;
	
}

}
class Person{
public int id;
public String name;
}
2.包装类
1、包装类： a、面向对象编程思想；b，基本数据类型变量，不能用对象使用的问题。 c、传输过程中对象传输，容器中皆为对象。

int --》 Integer
2、装箱和拆箱的过程（手动，自动）
基本数据 —》对应的包装类：装箱
拆箱：包装类—》对应的基本数据类型
3、基本数据类型和String类型的转换
一、基本数据类型转化为String类型
a, + “”;
b, String.valueof(基本数据类型);
二、String转化基本数据类型（包装类）
```
包装类.parseXXXX(字符串);
```
@author Administrator

*/
public class Demo2 {
public static void main(String[] args) {
List list = new ArrayList();
list.add(1);
int[] ii = {1,3,4};
System.out.println(list);

	Integer i = new Integer(100);
	int sum1 = 12 + i.intValue();  // 手动的拆箱
	int sum = 12 + i;  // 自动拆箱
	
	
	System.out.println(12 + "12"); // 1212
	String a = 12 + "";
	int b = 100;
	String.valueOf(b);
	Integer bb = new Integer(b);
	String bbStr = bb.toString();
	String abc = "3.1415";
	Double  s = Double.parseDouble(abc);
	
	System.out.println(12 + "");
	
}

}

3.java.util.Date 日期类
public class Demo3 {
public static void main(String[] args) {

	// 补充  java.sql.Date   只能获取年月日
	java.sql.Date sqlDate = new java.sql.Date(1597371055149L);
	// 
	System.out.println(sqlDate);
	
	
	
	Date d2 = new Date(1597371055149L);
	System.out.println(d2);
	
	Date oldDate = getDate("2019 08 14 10:19:40", "yyyy MM dd HH:mm:ss");
	
	while(true) {
		Date d1 = new Date();   // 2020-08-14 10:08:48.129  yyyy MM dd HH:mm:ss
		System.out.println(d1);
		/**
		 * 1\ yyyy-MM-dd HH:mm:ss
		 * 2\ yyyy/MM/dd 
		 * 3\ MM/yy
		 * 4\ HH:mm:ss
		 */
		SimpleDateFormat sdf = new SimpleDateFormat("yyyy MM dd HH:mm:ss");
		
		String dateStr = sdf.format(d1);
		System.out.println(dateStr);
		
		System.out.println(d1.getTime());	
		try {
			Thread.sleep(10000);
		} catch (InterruptedException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
	}
	
}

/**
 * 字符串转化为Date类   “2020 08 14 10:19:40”
 * @param strDate
 * @return
 */
public static Date getDate(String strDate,String format) {
	SimpleDateFormat sdf = new SimpleDateFormat(format);
	Date d = null;

	try {
		d = sdf.parse(strDate);
	} catch (ParseException e) {
		e.printStackTrace();
	}
	
	return d;
}

}

Calendar日历类使用

public class Demo4 {
public static void main(String[] args) {

	Calendar c = Calendar.getInstance();
	c.set(2020, 8, 14);
	// 获取年
	int year = c.get(c.YEAR);
	// 获取月
	int month = c.get(c.MONTH);
	
	// 获取日
	c.get(c.DAY_OF_MONTH);
	c.get(c.HOUR_OF_DAY);
	c.get(c.MINUTE);
	c.get(c.SECOND);
	System.out.println(year + " " + month );
	
	
}

}

5.java8 新特性日期

旧的： Date非线程安全的。API设计的比较乱。
java8:
java.time包下：
LocalDate : 年月日
LocaLDateTime: 年月日时间
LocatTime：时间

public class Date5 {
public static void main(String[] args) {
LocalDate date = LocalDate.now();
System.out.println(“当前日期：” + date);
// 获取年月日，周几
System.out.println(“年” + date.getYear());
System.out.println(“月” + date.getMonth());
System.out.println(“月(数字)” + date.getMonthValue());
System.out.println(“日” + date.getDayOfMonth());
System.out.println("周 " + date.getDayOfWeek());

	// 去年  明年
	LocalDate date1 = date.plusYears(1);
	System.out.println("加1 " + date1.getYear());
	
	LocalDate date2 = date.plusYears(-1);
	System.out.println("减一 " + date2.getYear());
	
	LocalDate date3 = date.plusMonths(1);
	System.out.println("加 月份：" + date3.getMonthValue());
	
	// 日期比较   
	boolean ifafter = date1.isAfter(date);
	System.out.println(ifafter);
	Boolean ifbefore = date1.isBefore(date);
	System.out.println(ifbefore);
	
	
	// LocaLDateTime
	LocalDateTime dateTime = LocalDateTime.now();
	System.out.println(dateTime);
	
	// DateTimeFormatter  LocalDateTime类转化字符串
	DateTimeFormatter dtf = DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss");
	String dateTimeStr = dtf.format(dateTime);
	System.out.println(dateTimeStr);
	
	// 字符串转化成LocalDateTime   LocalDate   LocalTime
	LocalDateTime.parse(dateTimeStr,dtf);
	LocalDate.parse(dateTimeStr,dtf);
	LocalTime.parse(dateTimeStr,dtf);
	
	
	// 日期时间差计算类    java.time.Duration
	LocalDateTime today = LocalDateTime.now();
	System.out.println("today :" + today);
	
	// 2020-12-12 12:12:12
	LocalDateTime datenew = LocalDateTime.of(2020, 12, 12, 12,12,12);
	// 日期差
	Duration dur = Duration.between(today, datenew);
	// 相差的天数
	System.out.println(dur.toDays());
	System.out.println(dur.toHours());
	System.out.println(dur.toMillis());
	
}

public void testLocalDateTime() {
	
	
}

}