java中equals、内部类、匿名内部类、Date的学习

最新推荐文章于 2022-08-10 15:43:23 发布
最新推荐文章于 2022-08-10 15:43:23 发布
阅读量274 收藏
点赞数
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_50551074/article/details/108739548
版权

o.复习

1.类和对象

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

抽象类和抽象方法 接口

静态 常量（final)

接口可以包括哪些成员：1.抽象方法2.默认方法 3.静态方法 4.常量

2.类和接口的区别：

1.类是单继承 接口是多实现

2.接口不是类 它和实现类的关系不是is a的关系 接口一组规范 使用接口必须通过实现类去使用

类和子类之间的关系满足is a ，类可以创建对象使用

3.类和接口包含的成员时不一样

4.多态：

1.有继承/实现关系

2.存在重写

3.父类引用指向子类对象

1.今日单词

Employee员工

Manager管理

2.学习目标

3.课堂笔记

1.薪资管理系统

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-ICi6kFC9-1600775405662)(C:\Users\lenovo\Desktop\java笔记\转岗.png)]

package EmplaySalaryManager;
//员工
public class Employee {
	//基本工资
	//计算基本工资的方法
	int  baseSalary;
	public int caculateSalary() {
		return baseSalary;
	}
	public Employee(int baseSalary) {
	
		this.baseSalary = baseSalary;
	}
	public Employee() {
		super();
	}
	
	

}


package EmplaySalaryManager;
//程序员
public class Programmer extends Employee {
   int bonus;//分红
   public int caculateSalary() {
		return super.caculateSalary()+bonus;
	}
public Programmer(int baseSalary, int bonus) {
	
	this.bonus = bonus;
}
public Programmer(int baseSalary) {
	super(baseSalary);
}

   
}


package EmplaySalaryManager;
//销售
public class SalaMan extends Employee {
    int salaAmount;//提成
    
    public int caculateSalary() {
		return super.caculateSalary()+salaAmount;
	}

	public SalaMan(int baseSalary, int salaAmount) {
	
		this.salaAmount = salaAmount;
	}

	public SalaMan(int baseSalary) {
		super(baseSalary);
	}
	
    
}


package EmplaySalaryManager;

import java.util.ArrayList;

public class EmployeeManager {
	
		ArrayList<Employee> allEmp;//保存所有员工
		public int getTotalSalary() {
			int totalSalary=0;//统计所有工资的
			for(int i=0;i<allEmp.size();i++) {
				totalSalary+=allEmp.get(i).caculateSalary();
			}
			return totalSalary;
		}
	}




package EmplaySalaryManager;

import java.util.ArrayList;

public class Test {
    public static void main(String[]args) {
    	Employee emp=new Employee(3000);
    	Programmer pro=new Programmer(3000,100000);
    	SalaMan sala=new SalaMan(3000,1000);
    	
    	
    	EmployeeManager manager=new EmployeeManager();
    	manager.allEmp=new ArrayList<>();
    	manager.allEmp.add(emp);
    	manager.allEmp.add(pro);
    	manager.allEmp.add(sala);
    	int salaryTo=manager.getTotalSalary();
    	System.out.println(salaryTo);
    }
}

2.转岗

​

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-urhJ3G9M-1600775405666)(C:\Users\lenovo\Desktop\java笔记\3.png)]

package EmplaySalaryManager;
//员工
public class Employee {
	//基本工资
	//计算基本工资的方法
	String name;//员工的名字
	String jobName;//岗位的名字
	
	Job jobtemp;//工作岗位
	//job作为员工的成员变量
	//降低了耦合度
	public int caculateSalary() {
		return jobtemp.caculateSalary();//计算某个员工的工资
		//多态        job岗位  多个岗位  程序员    销售   行政
	}

	
	

}


package EmplaySalaryManager;

import java.util.ArrayList;

public class EmployeeManager {
	
		ArrayList<Employee> allEmp;//保存所有员工
		public int getTotalSalary() {
			int totalSalary=0;//统计所有工资的
			for(int i=0;i<allEmp.size();i++) {
				totalSalary+=allEmp.get(i).caculateSalary();
			}
			return totalSalary;
		}
	}


package EmplaySalaryManager;
//普通员工的类改为job类
//
public class Job {
	int  baseSalary;
	public int caculateSalary() {
		return baseSalary;
	}
	public Job(int baseSalary) {
	
		this.baseSalary = baseSalary;
	}
	public Job() {
		
	}
	
	
}


package EmplaySalaryManager;
//程序员
public class Programmer extends Job{
   int bonus;//分红
   public int caculateSalary() {
		return super.caculateSalary()+bonus;
	}
public Programmer(int baseSalary, int bonus) {
	
	this.bonus = bonus;
}
public Programmer(int baseSalary) {
	super(baseSalary);
}

   
}


package EmplaySalaryManager;
//销售
public class SalaMan extends Job {
    int salaAmount;//提成
    
    public int caculateSalary() {
		return super.caculateSalary()+salaAmount;
	}

	public SalaMan(int baseSalary, int salaAmount) {
	
		this.salaAmount = salaAmount;
	}

	public SalaMan(int baseSalary) {
		super(baseSalary);
	}
	
    
}


package EmplaySalaryManager;

import java.util.ArrayList;

public class Test {
    public static void main(String[]args) {
    	Employee emp=new Employee();//创建一个员工   
    	//Employee emp=new Employee(3000);
    	emp.jobtemp =new Programmer(3000,100000);
    	 //new 的是一个岗位
    	//程序员转销售
    	emp.name="张三";
    	emp.jobName="销售";//不是转岗
    	//emp=new SalaMan(3000,1000);
    	//开除张三重新录用了给了一个销售的职位
    	//继承的耦合度高
    	//开闭原则
    	//高内聚低耦合
    	//解决转岗的问题   继承关系变成组合关系降低耦合度
    	//尽量使用组合
    	emp.jobName="程序员";
    	emp.jobtemp=new Programmer(3000,20000);
    	int salary=emp.caculateSalary();
    	System.out.println(salary);
    	
    	//emp.jobtemp =new SalaMan(3000,1000);
    	
    	
//    	EmployeeManager manager=new EmployeeManager();
//    	manager.allEmp=new ArrayList<>();
//    	manager.allEmp.add(emp);
//    	manager.allEmp.add(pro);
//    	manager.allEmp.add(sala);
//    	int salaryTo=manager.getTotalSalary();
//    	System.out.println(salaryTo);
    }
}

3.类与类之间的四大关系：

​ 1.泛化 子类和父类

​ 2.实现 实现类和接口

​ 3.关联/组合 一个类作为另一个类的成员变量

​ 4.依赖 B类型作为A类型某个方法的参数

4.接口中Comparator的学习

public static void main(String[] args) {
		int []  arr={11,2,3};
		Arrays.sort(arr);
		
		System.out.println(Arrays.toString(arr));
		
		
		//Dart number  count
		Dart dart=new  Dart(200, 150);
		
		Dart dart1=new  Dart(120, 60);
		
		Dart dart2=new  Dart(60, 400);
		
		Dart [] darts={dart,dart1,dart2};
		
		
		//按三个对象的number进行排序
		//1.参加排序的对象 实现一个接口 comparable
		//2.Dart类  能按着对象直接排序吗  不能 
		//3.提供排序的标准  Dart  number
		Arrays.sort(darts);
		//1.分析  一个类可以转换成某一个类型/接口  
		//  继承或者实现接口
		//子类转换成父类   实现类转换为接口
		
		//ExtendsDemo7.Dart cannot be cast to java.lang.Comparable
		//不能转换Dart类 为Comparable
		//就想完成排序 实现排序的规范  排序接口
		//Java中常用的接口
		//Comparable  Comparator
		//默认排序标准间        添加其他的排序标准
		
		for (int i = 0; i < darts.length; i++) {
			System.out.println(darts[i].number);
		}
		
		
		
		//按dart的count   进行排序
		
		//Comparable 接口 只能对一种标准进行排序 
		
	
	}
}

//单个比较
//比较的标准
@Override
	//和谁进行比较
	public int compareTo(Dart o) {
		// TODO Auto-generated method stub
		//this   o
		//this>o   返回1
		//this<o   返回-1
		//this=o   返回0
		if (this.count>o.count) {
			return 1;
		}
		else if (this.count<o.count) {
			return -1;
		}
		else {
			return 0;
		}
	}

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-ztKFasgy-1600775405669)(C:\Users\lenovo\Desktop\java笔记\4.png)]

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-w816pHpy-1600775405679)(C:\Users\lenovo\Desktop\java笔记\5.png)]

Comparable 接口 只能对一种标准进行排序

5.Comparator（可以实现对个排序）

//多个排序的标准

class  ComDart  implements Comparator<Dart>{

	@Override
	public int compare(Dart o1, Dart o2) {
		// TODO Auto-generated method stub
		if (o1.number>o2.number) {
			return 1;
		}
		else if (o1.number<o2.number) {
			return -1;
		}
		else {
			return 0;
		}
	}
	
}

Comparable 默认的排序标准

Comparator 添加其他的排序标准（不用和默认的写在一个类里边）

6.权限修饰符

java中有四种权限修饰符

权限修饰符是在定义类、方法、成员变量的时候用到的

场景 public protected (default) private

同一个类中 YES YES YES YES

同一个包中 YES YES YES NO

不同包，同一个子类中 YES YES NO NO

不同包，不用子类中 YES NO NO NO

7.常用API：

​ Object 类 万类之祖

Object类的作用：

​ 1.所有类都会继承Object

​ public class MyClss extends Object(){

​ }

9.euqals方法的学习

package ObjectDemo;

public class Student {
	
	Comparable<Student> com;

	int age;
	
	String name;

	public Student(int age, String name) {
		this.age = age;
		this.name = name;
	}

	@Override
	public String toString() {
		return "age=" + age + ", name=" + name + "";
	}

	@Override
	public int hashCode() {
		final int prime = 31;
		int result = 1;
		result = prime * result + age;
		result = prime * result + ((name == null) ? 0 : name.hashCode());
		return result;
	}

	@Override
	public boolean equals(Object obj) {
		if (this == obj)
			return true;
		if (obj == null)
			return false;
		if (getClass() != obj.getClass())//反射
			//obj instanceof Student
			return false;
		Student other = (Student) obj;
		if (age != other.age)
			return false;
		if (name == null) {
			if (other.name != null)
				return false;
		} else if (!name.equals(other.name))
			return false;
		return true;
	}


//	@Override
//	public boolean equals(Object obj) {
//		//Object obj 父类 多态的弊端 不能直接访问子类的成员变量
//		// TODO Auto-generated method stub
//		//比较 this 和 obj
//		if (obj instanceof Student) {
//			Student st=(Student)obj;
//			if (this.age==st.age&&this.name.equals(st.name)) {
//				return true;
//			}
//			else {
//				return false;
//			}		
//		}
//		return false;
//	}
	
//	@Override
//	public boolean equals(Object obj) {
//		// TODO Auto-generated method stub
//		if (this==obj) {
//			return true;
//		}
//		if (obj==null) {
//			return false;
//		}
//		//做判断
//		if (obj instanceof Student) {
//			Student st = (Student) obj;//强制转换
//			if (this.age!= st.age) {
//				return false;
//				
//			} else {
//				if (this.name!=st.name) {
//					return false;
//				}
//				else {
//					return true;
//				}
//			}
//		}
//		return false;
//	}
	


	
}


package ObjectDemo;

import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.ArrayList;
import java.util.Date;
import java.util.Random;
import java.util.Scanner;

import javax.xml.crypto.Data;

public class Test {

	public static void main01(String[] args) {
		 //Student stu=new Student();
		 //学习Object  
		 //toString方法  和  Equals
		 
		 Student stu=new Student(10, "小洪");
		 // return getClass().getName() + "@" + Integer.toHexString(hashCode());
		 System.out.println(stu.toString());//ObjectDemo.Student@726f3b58
	
	
		 Random random=new Random();//random 没有重写tostring
		 System.out.println(random.toString());//java.util.Random@442d9b6e
		 
		 Scanner scanner=new Scanner(System.in);
		 System.out.println(scanner.toString());//Scanner重写了tistring
		 //java.util.Scanner[delimiters=\p{javaWhitespace}+][position=0][match 
	
	
		 ArrayList<Student> s=new ArrayList<>();
		 s.add(new Student(10, "小张"));
		 s.add(new Student(20, "小王"));
		 System.out.println(s);
		 
		 //ArrayList  重写了Object Tostring
	}

	public static void main(String[] args) {
		Student stu=new Student(19, "张三丰");
		Student stu2=new Student(19, "张三丰");
		System.out.println(stu==stu2);//false
		
		System.out.println(stu.equals(stu2));//false
		System.out.println("==============");
		String str=new String("张三丰");
		String str1=new String("张三丰");
		
		System.out.println(str==str1);//比较地址  false
		System.out.println(str.equals(str1));//比较的是值 true
小提示：

**##### 在字符串的比较中equals和==是完全不同的，euqal是判断创建的两个对象的值是否相等而==是创建两个对象的地址是否相等。

public static void main(String[] args) {
		Student stu=new Student(19, "张三丰");
		Student stu2=new Student(19, "张三丰");
		System.out.println(stu==stu2);//false
		
		System.out.println(stu.equals(stu2));//false
分析:

​ 问题1：常理equals比较的是两个对象创建的值是否相等 stu和stu2两个对象应该是一样的为什么 System.out.println(stu.equals(stu2));返回一个false呢？

解答：

​ 没有重写equals方法 (此案例中student虽然继承了父类equals并没有重写equals方法所以stu.equals(stu2)的时候返回了false)

​ 问题2：如何将stu.euals(stu2)比较返回的值为true呢？

​ 解答： 在Student类里边重写equals方法当子类中重写了equals方法之后会优先访问自己的equals方法

没有再网上找。

​ [外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-M6kXaR7P-1600775405681)(C:\Users\lenovo\Pictures\2020-09-22_152341.png)]

​

String str=new String("张三丰");
		String str1=new String("张三丰");
		
		System.out.println(str==str1);//比较地址  false
		System.out.println(str.equals(str1));//比较的是值 true
分析：
  1. String类在比较的时候重写了toString方法因此System.out.println(str.equals(str1))返回一个true.
  2. String类重写了toString之后将字符串中的每一个字符去做比较如果全部相同返回true，如果不相同返回的是false;
  3. 字符串中toString的重写

​ [外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-Xz626qXM-1600775405682)(C:\Users\lenovo\Desktop\java笔记\2020-09-22_145540.png)]

分析1：
                  public boolean equals(Object anObject) {
    if (this == anObject) {
        return true;
    }

判断连个对象是否相等如果相等直接返回true;

分析2：
                ```

if (anObject instanceof String) {

                ```

判断对象是不是当前比较的对象是不是为一个类型

分析3：
String anotherString = (String)anObject;

将对象强转为字符串

分析4：

​ [外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-E3L6lea3-1600775405683)(C:\Users\lenovo\Desktop\java笔记\2020-09-22_151204.png)]

​ 当前字符串的长度和要比较的字符串的长度是否一样如果一样将两个字符串分别转成了一个数组

​ 然后将数组中的每一项进行比较如果遇到不一样的返回false,如果直到循环完之后没有遇到不一样的 则返回true.

总结：在判断两个对象是相等的时候要特别注意equals是否得到重写如果重写了还要注意在比较的时候还要进行广泛的比较不能只凭借一个值比较的结果而做出主观的判断

10.内部类的学习

1. 内部类 ：

​ 内部类如同我们的身体和心脏的关系当心脏脱离了我们的身体时候失去了跳动的作用 我们的身体也就无法活动内部类也是如此如果内部类脱离了外部类失去它原本的作用。

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-CZDYZBS5-1600775405685)(C:\Users\lenovo\Desktop\java笔记\2020-09-22_154245.png)] [外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-7OeCOz2I-1600775405686)(C:\Users\lenovo\Desktop\java笔记\2020-09-22_154839.png)]

2 .内部类的语法：

​ 权限修饰符 class关键字 外部类的类名{

​ 权限修饰符 class关键字 内部类的类名{

​ 内部类的方法（）{

​ 方法体

​ }

​ }

​ 外部类的方法（）{

​ 外部类的方法体

​ } ‘

​ }

3.内部类的案例：

​

package ObjectDemo;

/**
 * 外部类身体 包含  内部类 心脏
 * @author XuYang
 *
 */
public class Body {

	int number;
	/**
	 * 内部类
	 * @author XuYang
	 *
	 */
	public  class  Heart{
		//内部类方法
		public void   beat(){
			number=100;
			run();
			System.out.println("扑通扑平的");
		}
	}
	//外部类方法 
	public  void run(){
		System.out.println("跑起来");
	}
	
	
}
  1. 内部类的使用：
         编译器如何处理内部类  Body.java--->body.class
        Body.Heat.java---->Body$Heart.class
5.访问权限：
              1.内用外   随意访问
//2.外部用内部  
//普通类使用方式 类名称  对象名=new  类名称();
//内部类   外部类名称.内部类名称  内部类对象=new  外部类名称().new  内部类名称();
6.案例：
          public static void main01(String[] args) {
	Body body=new Body();
	
	Body.Heart   heart=new Body().new Heart();
	heart.beat();
	
	MyOuter.MyInner  inner=new MyOuter().new MyInner();
	inner.func();
	
}
7.内部类如果有同名
ackage ObjectDemo;

 class MyOuter {

	int number=10;
	public class  MyInner{
		int number=20;
		
		public void  func(){
			int number=30;
			System.out.println(MyOuter.this.number);//外部类number
			System.out.println(this.number);//内部类成员number
			System.out.println(number);//局部变量number
		}
	}
	
	
	public  void  outerFunc(){
		final int  number2=200;//属于方法  存储在栈上
		
		//局部内部类
		class  Inner{
			public int number=10;
			
			public void  innerFunc(){
	
				System.out.println(number2);
				System.out.println(number);
			}
		}
		
		Inner inner=new Inner();//堆上开内存
		//问题:inner内存还在  number2已经出栈了  要求number2不能修改
		inner.number=2000;
		inner.innerFunc();
	}
}


        ```

内部类如果有同名
// System.out.println(MyOuter.this.number);//外部类number
// System.out.println(this.number);//内部类成员number
// System.out.println(number);//局部变量number

        ```
解析：

​ 内部类如果有重名时要输出外部类中成员变量的值语法：

​ 外部类的类名 . this关键字 .要输出的成员变量

​ 内部类如果有重名时要输出内部类中成员变量的值语法：

​ this关键字.要输出的成员变量

​ 内部类如果有重名时要输出局部变量的值的语法：

​ 要输出的局部变量

8.访问修饰符的总结

​ 对于内部类而言四种访问修饰符都可以使用（public protected default private)

​ 外部类的修饰符只有public default

​

9.局部内部类：
1. 什么时局部内部类：

​ 如果一个类定义在一个方法内部 这个类就是局部内部类

2.局部内部类的特点：

​ 局部内部类 只属于当前的方法，所以只有当前方法可以使用他 出了方法就没有了

3.语法：
                       ```

public void outerFunc(){
final int number2=200;//属于方法 存储在栈上

	//局部内部类
	class  Inner{
		public int number=10;
		
		public void  innerFunc(){

			System.out.println(number2);
			System.out.println(number);
		}
	}
	
	Inner inner=new Inner();//堆上开内存
	//问题:inner内存还在  number2已经出栈了  要求number2不能修改
	inner.number=2000;
	inner.innerFunc();
}
                       ```
注意：局部内部类没有权限修饰符
10.局部内部类使用注意事项
           //1.如果局部内部类中的方法希望访问类 所在方法的局部变量   这个局部变量必须是有效final的
//Java8以后   只要局部变量 是事实不变的  final可以省略

案例：

         public  void  outerFunc(){
	final int  number2=200;//属于方法  存储在栈上
	
	//局部内部类
	class  Inner{
		public int number=10;
		
		public void  innerFunc(){

			System.out.println(number2);
			System.out.println(number);
		}
	}
	
	Inner inner=new Inner();//堆上开内存
	//问题:inner内存还在  number2已经出栈了  要求number2不能修改
	inner.number=2000;
	inner.innerFunc();
}
注意：
如果局部内部类如果想要访问方法的局部变量 方法中的局部变量的值必须是不可变的如果变了就会报错
 原因：
//1.new出来的对象 在堆上存储
//2.局部变量是跟着方法走的，存在栈中  
//3方法调用完成 局部变量就出栈了
//4.new 出来的对象  会在堆中持续存在  直到垃圾回收 

//所以 可能 number已经没有了  内部类对象还有   需要把number copy出来  copy出来到常量池

11.匿名内部类的学习

​ 1.匿名内部类 lambda表达式前提

2.什么情况下使用匿名内部类：

​ 如果、接口实现类或者父类的子类 只需要使用一次 而且是唯一的一次这种情况下 就可以省略实现类 或子类的定义 改为使用匿名内部类

3.匿名内部类的语法：
               接口名称/抽象类名称 对象名=new  接口名称/抽象类名称(){
//重写接口和抽象类的抽象方法
 //}
4.调用：

​ 对象名.抽象方法

​

5.使用内部类的注意事项：
                 //格式解析 
//1.new 代表创建对象的动作
//2.接口名称就是匿名内部类需要实现的接口

//3{。。。。} 这才是匿名内部类的内容
说明：
//1.匿名内部类 在创建对象的时候 只能使用一次 
//2.匿名对象 在调用方法的时候 只能使用一次
//3.匿名内部类 是省略了实现类或者子类  匿名对象是省略了对象名称
总结：
引用(类 接口)类型作为成员变量 ，返回值和参数
 public static void main(String[] args) {
   	//匿名对象和匿名类
   	new MyClass(){
   		@Override
   		public void func() {
   			System.out.println("哈哈哈,我只用一次");
   			
   		};
   	}.func();
   	//匿名内部类  类匿名  没有这个类  类只用一次(创建对象 使用类)
   	//匿名对象      对象匿名  没有这个对象  做参数  做返回值   对象只需要用一次
   	

   	
   	
   }
   //接口作为返回值
   public Comparable<Dart>  func(){
   	return new Dart(10, 100);
   }
//    public static Student  func( Student s){
//    	MyClass myClass=new MyClass() {
//			
//			@Override
//			public void func() {
//				// TODO Auto-generated method stub
//				
//			}
//		};
//    }
}


package ObjectDemo;

public abstract class MyClass {

	public abstract void  func();
}

12.DateFormat的学习

​ 1.DateFormat是java .text包中的

2.DateFormat的意思是：

​ 是日期/时间格式化子类的抽象类

3.作用：
                      ```

日期/时间格式化 1 00：00:01 1￥ 001
1999-11-11 1999:11:11 1999年11月11日
```

4.DateFormat的的构造方法

​ SimpleDateFormat(String pattern)

5.方法：
                        ```

String format(Date) 日期–》字符串
Date parse(String str) 字符串–>日期
```

6. 案例：
public class DateFormat {

 public static void main(String[] args) throws ParseException {
 	SimpleDateFormat sim=new SimpleDateFormat("yyyy-MM月dd HH:mm:ss");
 	//创建一个 简单时间格式化对象 
 	System.out.println(new Date());
 	//打印当前时间
 	String string= sim.format(new Date());
 	//把当前时间转换成 固定的格式
 	System.out.println(string);
 	//打印当前时间的一种格式
 	
 	System.out.println("=============");
 	Date date= sim.parse("1999-11-12 01:01:01");
 	System.out.println(date);
 	
 	System.out.println(date.getTime());
 	//System.out.println(sim);//没有重写toString
 }
}

13.时间有关的API Date的学习

Date的含义：

​ 表示特定的瞬间，精确到毫秒。

毫秒：

​ 毫秒:千分之一秒 1000毫秒=1秒

瞬间：

​ 2000-01-01 01:01:01:001 瞬间

​ 2000-01-01 01:01:01:002 瞬间

作用：

​ 可以对时间和日期进行计算

类中的构造函数和方法：
               ```

1.Date date=new Date();
2.Date date=new Date(0);
```

​

案例：如何计算2010-2020年有多少天？

​ 思路：

                                 ```

可以先把时间转换为毫秒 进行计算 计算完成之后 毫秒转为天数

  • 日期转毫秒

  • 2010-起始点 getTime方法 获取毫秒 上

  • 2020-起始点 getTime 方法 获取毫秒 下

  • 毫秒转为天数

  • 毫秒/12460601000
    ```

public class DateTest {

public static void main(String[] args) {
	Date date=new Date();//创建时间对象  
	System.out.println(date.toString());//Date重写了toString
    System.out.println(date.getTime());
	Date date2=new Date(0);
	System.out.println(date2);//起始时间  
	System.out.println(date2.getTime());
	
	long second=date.getTime()-date2.getTime();
	long day=second/(1*24*60*60*1000);
	System.out.println(day);
	
}

}


###### 注意：

​        默认的开始时间是1970 年 1 月 1 日 00:00:00   

​        根据地区的不同开始的时间也不同   中国（东八区  1970 年 1 月 1 日 08:00:00 ）

### 14.Calendar日历的学习

1.calendar是一个抽象类



2.calendar是java.util包下的

######    3.实现类：

​            GregorianCalendar

######     4.构造方法：

​             Calendar()

​             Calendar(Timezone zone,Locale  aLocale)

######    5.calendar的含义：

​             `Calendar` 类是一个抽象类，它为特定瞬间与一组诸如  `YEAR`、`MONTH`、`DAY_OF_MONTH`、`HOUR`  等 [`日历字段`](../../java/util/Calendar.html#fields)之间的转换提供了一些方法

######    6.方法的：

方法摘要
abstract void add(int field, int amount)
根据日历的规则，为给定的日历字段添加或减去指定的时间量。
boolean after(Object when)
判断此 Calendar 表示的时间是否在指定 Object 表示的时间之后，返回判断结果。
boolean before(Object when)
判断此 Calendar 表示的时间是否在指定 Object 表示的时间之前，返回判断结果。
void clear()
将此 Calendar 的所日历字段值和时间值（从历元至现在的毫秒偏移量）设置成未定义。
void clear(int field)
将此 Calendar 的给定日历字段值和时间值（从历元至现在的毫秒偏移量）设置成未定义。
Object clone()
创建并返回此对象的一个副本。
int compareTo(Calendar anotherCalendar)
比较两个 Calendar 对象表示的时间值（从历元至现在的毫秒偏移量）。
protected void complete()
填充日历字段中所有未设置的字段。
protected abstract void computeFields()
将当前毫秒时间值 time 转换为 fields[] 中的日历字段值。
protected abstract void computeTime()
将 fields[] 中的当前日历字段值转换为毫秒时间值 time。
boolean equals(Object obj)
将此 Calendar 与指定 Object 比较。
int get(int field)
返回给定日历字段的值。
int getActualMaximum(int field)
给定此 Calendar 的时间值，返回指定日历字段可能拥有的最大值。
int getActualMinimum(int field)
给定此 Calendar 的时间值，返回指定日历字段可能拥有的最小值。
static Locale[] getAvailableLocales()
返回所有语言环境的数组，此类的 getInstance 方法可以为其返回本地化的实例。
String getDisplayName(int field, int style, Locale locale)
返回给定 style 和 locale 下的日历 field 值的字符串表示形式。
Map<String,Integer> getDisplayNames(int field, int style, Locale locale)
返回给定 style 和 locale 下包含日历 field 所有名称的 Map 及其相应字段值。
int getFirstDayOfWeek()
获取一星期的第一天；例如，在美国，这一天是 SUNDAY，而在法国，这一天是 MONDAY。
abstract int getGreatestMinimum(int field)
返回此 Calendar 实例给定日历字段的最高的最小值。
static Calendar getInstance()
使用默认时区和语言环境获得一个日历。
static Calendar getInstance(Locale aLocale)
使用默认时区和指定语言环境获得一个日历。
static Calendar getInstance(TimeZone zone)
使用指定时区和默认语言环境获得一个日历。
static Calendar getInstance(TimeZone zone, Locale aLocale)
使用指定时区和语言环境获得一个日历。
abstract int getLeastMaximum(int field)
返回此 Calendar 实例给定日历字段的最低的最大值。
abstract int getMaximum(int field)
返回此 Calendar 实例给定日历字段的最大值。
int getMinimalDaysInFirstWeek()
获取一年中第一个星期所需的最少天数，例如，如果定义第一个星期包含一年第一个月的第一天，则此方法将返回 1。
abstract int getMinimum(int field)
返回此 Calendar 实例给定日历字段的最小值。
Date getTime()
返回一个表示此 Calendar 时间值（从历元至现在的毫秒偏移量）的 Date 对象。
long getTimeInMillis()
返回此 Calendar 的时间值，以毫秒为单位。
TimeZone getTimeZone()
获得时区。
int hashCode()
返回该此日历的哈希码。
protected int internalGet(int field)
返回给定日历字段的值。
boolean isLenient()
判断日期/时间的解释是否为宽松的。
boolean isSet(int field)
确定给定日历字段是否已经设置了一个值，其中包括因为调用 get 方法触发内部字段计算而导致已经设置该值的情况。
abstract void roll(int field, boolean up)
在给定的时间字段上添加或减去（上/下）单个时间单元，不更改更大的字段。
void roll(int field, int amount)
向指定日历字段添加指定（有符号的）时间量，不更改更大的字段。
void set(int field, int value)
将给定的日历字段设置为给定值。
void set(int year, int month, int date)
设置日历字段 YEAR、MONTH 和 DAY_OF_MONTH 的值。
void set(int year, int month, int date, int hourOfDay, int minute)
设置日历字段 YEAR、MONTH、DAY_OF_MONTH、HOUR_OF_DAY 和 MINUTE 的值。
void set(int year, int month, int date, int hourOfDay, int minute, int second)
设置字段 YEAR、MONTH、DAY_OF_MONTH、HOUR、MINUTE 和 SECOND 的值。
void setFirstDayOfWeek(int value)
设置一星期的第一天是哪一天；例如，在美国，这一天是 SUNDAY，而在法国，这一天是 MONDAY。
void setLenient(boolean lenient)
指定日期/时间解释是否是宽松的。
void setMinimalDaysInFirstWeek(int value)
设置一年中第一个星期所需的最少天数，例如，如果定义第一个星期包含一年第一个月的第一天，则使用值 1 调用此方法。
void setTime(Date date)
使用给定的 Date 设置此 Calendar 的时间。
void setTimeInMillis(long millis)
用给定的 long 值设置此 Calendar 的当前时间值。
void setTimeZone(TimeZone value)
使用给定的时区值来设置时区。
String toString()
返回此日历的字符串表示形式。




  ```
package DateDemo;

import java.util.Calendar;
import java.util.GregorianCalendar;

/**
* Calendar 日历
* 抽象类
* 操作日历字段（例如获得下星期的日期）提供了一些方法。
* 子类：
* 不好看
* 
* static Calendar getInstance(Locale aLocale) 
        使用默认时区和指定语言环境获得一个日历。 
* @author XuYang
*
*/
public class GalendarTest {

  public static void main(String[] args) {
  	
  	
  	
  	Calendar calendar2=Calendar.getInstance();
  	System.out.println(calendar2);
  	
  	
  }
}

  ```



TH 和 DAY_OF_MONTH 的值。 
void set(int year, int month, int date, int hourOfDay, int minute) 
        设置日历字段 YEAR、MONTH、DAY_OF_MONTH、HOUR_OF_DAY 和 MINUTE 的值。 
void set(int year, int month, int date, int hourOfDay, int minute, int second) 
        设置字段 YEAR、MONTH、DAY_OF_MONTH、HOUR、MINUTE 和 SECOND 的值。 
void setFirstDayOfWeek(int value) 
        设置一星期的第一天是哪一天；例如，在美国，这一天是 SUNDAY，而在法国，这一天是 MONDAY。 
void setLenient(boolean lenient) 
        指定日期/时间解释是否是宽松的。 
void setMinimalDaysInFirstWeek(int value) 
        设置一年中第一个星期所需的最少天数，例如，如果定义第一个星期包含一年第一个月的第一天，则使用值 1 调用此方法。 
void setTime(Date date) 
        使用给定的 Date 设置此 Calendar 的时间。 
void setTimeInMillis(long millis) 
        用给定的 long 值设置此 Calendar 的当前时间值。 
void setTimeZone(TimeZone value) 
        使用给定的时区值来设置时区。 
String toString() 
        返回此日历的字符串表示形式。 


```

package DateDemo;

import java.util.Calendar;
import java.util.GregorianCalendar;

/**

  • Calendar 日历
  • 抽象类
  • 操作日历字段（例如获得下星期的日期）提供了一些方法。
  • 子类：
  • 不好看
  • static Calendar getInstance(Locale aLocale)
    使用默认时区和指定语言环境获得一个日历。
  • @author XuYang

*/
public class GalendarTest {

public static void main(String[] args) {
	
	
	
	Calendar calendar2=Calendar.getInstance();
	System.out.println(calendar2);
	
	
}

}

```
猿字羌
关注
Flutter _ 如何优雅的开发一个插件并发布到Dart仓库？，kotlin匿名内部类内存泄露
sa3221sa的博客
01-11 495
本文仅介绍 Flutter 插件包的整个开发与发布流程，至于 Dart 包，过程都是类似的，读者可以查阅相关文章进行了解。 创建 Flutter 插件包项目 正文开始前，读者需要对 Flutter 的平台通道有所了解，如果你还不知道，可以先阅读我之前写的Flutter | 如何优雅的调用 Android 原生方法？，然后再回来继续本文的学习。如果你已经掌握平台通道的相关知识，跟着我的步伐，继续往下~ 本文将带读者在 Android 平台上实现一个调节音量大小的插件包项目，并发布到 Dart 仓库。首先打开
Java 7 day--内部类、垃圾回收机制、异常、常用类（Date类、Calendar类、Math类、枚举类）
qq_43698131的博客
04-24 323
内部类、垃圾回收机制、异常、常用类（Date类、Calendar类、Math类、枚举类）
java中集合、增强for循环、以及API的学习
m0_50551074的博客
09-23 316
o.复习 1.类和对象 面向对象三大特性：封装 继承 多态 抽象类和抽象方法 接口 静态 常量（final) 接口可以包括哪些成员：1.抽象方法2.默认方法 3.静态方法 4.常量 2.类和接口的区别： 1.类是单继承 接口是多实现 2.接口不是类 它和实现类的关系不是is a的关系 接口一组规范 使用接口必须通过实现类去使用 类和子类之间的关系满足is a ，类可以创建对象使用 3.类和接口包含的成员时不一样 4.多态： 1.有继承/实现关系 2.存在重写 3.父类
匿名内部类的讲解
hbuwanglei的博客
04-13 330
转载自：http://www.cnblogs.com/nerxious/archive/2013/01/25/2876489.html 不使用匿名内部类来实现抽象方法 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 abs
java内部类和匿名内部类
StormMaybin的博客
04-25 478
/** *@author：StormMaybin *@Date:20160425 */ 最近看到了java内部类和匿名内部类，所以写篇博客加强记忆！ 所谓内部类就是定义在类中的类，那么匿名内部类就是定义在内部类中没有类名的类！废话不多说，直接码代码来分析： class Outer {     private double PI = 3.14;     class Inne
days13--内部类与匿名内部类
weixin_44624060的博客
05-17 91
匿名类
java内部学习笔记.docx
02-18
1. Object类：所有Java类的根类，包含equals()、hashCode()等基本方法。 2. String类：不可变的字符序列，广泛用于文本处理。 3. StringUtils类：Apache Commons Lang提供的字符串操作工具类。 4. StringBuilder类：...
Java list.sort(new Comparator{}) LIst集合排序 和匿名内部类
qq_45858803的博客
11-27 2210
package Collection; import java.util.ArrayList; import java.util.Comparator; import java.util.List; /** * List集合排序 * sort(Comparator) */ public class Test { public static void main(String[] args) { //创建List集合,存储Person对象 List<
Java学习第五章-内部类与常用类（String，包装类）
langMR的博客
07-16 390
内部类与常用类
Java八大常用类小结
qq_46080582的博客
08-10 502
成员内部类成员内部类：类比成员方法，不能拥有静态域但是可以访问外部类的静态域示例静态内部类定义在外部类的内部，使用static修饰，类比静态方法，静态内部类不需要外部类对象产生就能使用，不能访问外部类的成员域，但能访问静态域静态内部类的创建语法：1.外部类内部：与成员内部类一样2.外部类外部：StaticInnerClass.Inner inner = new StaticInnerClass.Inner();局部内部类定义在方法内部：类比局部变量。......
Day 13 泛型、匿名内部类和集合
01-21
Day 13 1. 泛型 1.1 什么是泛型，为什么引入泛型 目前项目，功能是可以考虑之后的复用的。当前代码值支持Student类，如果需要更换数据类型，智能重新完成对应数据类型的功能键代码。 这里不单单是对于功能模块的要求而封装。统统是需要对数据类型进行统一的约束。根据用户的要求队形数据类型。 Java中的泛型就是来解决对应的问题 格式 T Type E Element K Key V Value 泛型可以在方法中使用 泛型可以在类中使用 泛型可以在接口中使用 1.2 泛型在方法中使用 格式 public static 返回值类型[自定义类型] 方法名(自定
Dart 匿名方法
qq_25020915的博客
01-14 1438
学习flutter的时候，每次看到 GestureDetector( // ignore: named_function_expression onTap:(){ }， ... ) 我都有疑问，这是什么，监听事件往往都是通过回调对外提供支持，flut...
第九天(下) 匿名对象和内部类
weixin_34228387的博客
08-11 76
匿名对象匿名对象是指在创建对象的时,只有创建对象的语句,却没有把对象地址赋值给某个变量.publicclassPerson{ publicvoideat(){ System.out.println(""); } }创建一个普通对象Personp=newPerson();匿名对象newPerson();特点创建匿名对象直接使用,...
Dart匿名方法函数和闭包
weixin_30325071的博客
06-15 174
/* 内置方法/函数： print(); 自定义方法： 自定义方法的基本格式： 返回类型 方法名称（参数1，参数2,...）{ 方法体 return 返回值; } */ void printInfo(){ print('我是一个自定义方法'); } int...
（十五）Date、SimpleDateFormat、Calendar类和内部类
程序媛乐园
08-14 217
学习内容 Date类 Date类的概述 类 Date 表示特定的瞬间，精确到毫秒。 构造方法 public Date() public Date(long date) 成员方法 public long getTime() public void setTime(long time) SimpleDateFormat类实现日期和字符串的相互转换 DateFormat类的概述 DateFormat 是日期/时间格式化子类的抽
【Dart学习】-- Dart之匿名方法&闭包
weixin_33835103的博客
06-17 328
一，匿名方法定义 （参数1,参数2,....）{ 方法体... return 返回值 } 二，匿名方法特性 可赋值给变量，通过变量进行调用 可在其他方法中直接调用或传递给其他方法 void main(List<String> args) {//无参匿名函数　var func = () { 　 print("Hello...
dart语言学习（十八）— 匿名方法
黄孝果的博客
12-15 1377
定义 （参数1,参数2,....）{ 方法体... return 返回值 } 可赋值给变量，通过变量进行调用 可在其他方法中直接调用或传递给其他方法 void main(List&lt;String&gt; args) { var func = () { print("Hello"); }; func(); var func1 = (str) { ...
重新认识匿名内部类，构造过滤器链
chuangjuan5300的博客
06-27 148
昨晚看了一下dubbo过滤器链的创建，对java基础的匿名内部类做了一部分了解，也算是巩固了一下基础吧，基础确实很重要。 //dubbo ProtocolFilterWrapper 构建过滤器链 private static <T> Invok...
Java匿名内部类可以访问外部类的成员；若访问所在方法的成员，那个成员必须具有final属性
zzu::myorange
08-24 2212
先上图 图中匿名内部类实现的监听器若访问所在成员方法onCreated中的editText方法，editText必须就有final属性，因为多线程的生命周期问题。onCreate所在线程可能早结束于匿名内部类，导致editText变量的生命周期也结束了。而监听器还在工作，它要访问editText怎么办呢？那就需要editText具有final属性，值不允许改变。 而外部类中的成员，局部
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值