day04 【常用API】toString方法、equals方法、Date类、Math类、System类

day04 【常用API】

反馈和复习
1.多态
    多态: 一个对象可以有不同的形态
    比如:
		Animal an = new Dog();
		Animal an = new Cat();
	前提:
		a.继承关系或者实现关系
        b.要有方法的重写
    表现形式:
		父类类型/接口类型 变量名 = new 子类()/new 实现类();
	好处:
		提高代码的扩展性(喂猫喂狗案例)
    弊端:
		多态的情况,只能调用子父类共有的方法,无法调用子类特有的方法
    解决弊端的方案:
		向上转型:
			Animal an = new Dog();
		向下转型:
			Dog d = (Dog)an;
			Cat c = (Cat)an;
	关键字:
		boolean b = an instanceof Dog
2.内部类
    重点介绍匿名内部类:
		父类/接口 变量名 = new 父类/接口(){
            重写父类或者接口中所有的抽象方法
            //特有方法
            public void show(){
                ....
            }    
        };
	问题:
		如果匿名内部类中,有特有方法.我们怎么向下转型来调用它??
        是无法向下转型(因为匿名内部类没有类名)    
    结论:
		如果想使用匿名内部类,就不要在{}中写特有方法
    
3.权限修饰符
     public protected 空的 private
     public:修饰成员方法和构造方法       
     private:修饰成员变量
4.代码块  
     代码块: 就是使用大括号括起来的一句或者多句代码
     构造代码块:
		{
            构造代码块
        }
		执行: 每次创建对象时,构造代码块都会执行,优先于构造方法执行
	 静态代码块:
		static{
            静态代码块
        }
		执行:第一加载该类时,静态代码块会执行一次,优先于构造方法执行的
今日内容
day04和day05主要介绍一堆Java中写好的类(抽象类)
今天:
	Object类(所有类的共同父类)
    Date类(时间日期类) 
    DateFormat(时间日期的格式化类) 
    Calendar(时间日期类)    
    Math类(和数学计算相关的类)
    System类(主要介绍两个方法)   
    一共有:20-30个方法

第一章 Object类【重点】

1.1 Object类的介绍
Object类是所有类的父类,所有对象(包括数组)都具有该类中的11个方法
注意:
	如果一个类我们没有指定其父类,那么默认继承Object
    public class Dog /*extends Object*/ {
	}   
1.2 toString方法
toString方法:
	作用: 返回该对象的字符串表示
    默认字符串表示的形式:
			包名.类名@地址值
            比如:com.itheima.demo01_Object01.Dog@4554617c
	
    在实际开发中,我们通常会重写toString方法,将本类返回的地址值改成返回该对象中的内容

   public class Dog /*extends Object*/ {
        int age;
        String name;
        public Dog() {
        }
        public Dog(int age, String name) {
            this.age = age;
            this.name = name;
        }
        //重写toString
    //    @Override
    //    public String toString() {
    //        //不要返回地址值,返回对象的内容
    //        return this.age + "...." + this.name;
    //    }
        //绝大多数的开发工具(IDEA,Eclipse,...),都会有自动生成toString方法的功能
        //快捷键:alt+insert
        @Override
        public String toString() {
            return "Dog{" +
                    "age=" + age +
                    ", name='" + name + '\'' +
                    '}';
        }
    }

    public class TestDemo {
        public static void main(String[] args) {
            //1.创建Dog对象
            Dog dd = new Dog(10,"旺财");
            //2.调用toString方法
            String ss = dd.toString();
            //com.itheima.demo01_Object01.Dog@4554617c
            System.out.println(ss);

            //3.再来一个对象
            Dog dd2 = new Dog(20,"来福");
            String ss2 = dd2.toString();
            //com.itheima.demo01_Object01.Dog@74a14482
            System.out.println(ss2);
        }
    }
	输出结果:
	Dog{age=10, name='旺财'}
	Dog{age=20, name='来福'}

	注意事项:
		我们重写了toString之后,当调用对象的toString方法时,返回的不再是地址值,而是具体的属性值
        实际上,我们不需要手动调用toString方法,
				Dog d = new Dog();
				String s = d.toString();
              	System.out.println(s);
				我们只需要:
				Dog d = new Dog();
				System.out.println(d);
				因为我们打印变量名d,编译器会自动调用d.toString(),
				其实打印就是toString方法的方法返回值
         总之:
				System.out.println(变量名.toString())
                等价于
                System.out.println(变量名);    	
1.3 equals方法
equals方法:
	作用:判断其他某个对象是否与此对象“相等”。
    默认比较的是什么???
        默认比较的是两个对象的地址值!!!
    在实际开发中,我们也会重写equals方法,将本来的比较地址值改成比较内容 
        
public class Cat {
    int age;
    String name;
    public Cat() {
    }
    public Cat(int age, String name) {
        this.age = age;
        this.name = name;
    }
    //重写equals
    //使用IDea工具即可,alt+inseret
    @Override
    public boolean equals(Object o) {
        //合法性判断
        if (this == o) return true;
        if (o == null || getClass() != o.getClass()) return false;
        Cat cat = (Cat) o;
        //判断是 必须是 当前对象的age和比较对象的age相同,且当前对象的name和比较对象的name相同,才返回true
        return age == cat.age &&
                Objects.equals(name, cat.name);
    }
}
   
public class TestDemo {
    public static void main(String[] args) {
        //1.创建个两个对象
        Cat c1 = new Cat(10,"加菲猫");
        Cat c2 = new Cat(10,"加菲猫");
        //2.调用equals方法
        boolean b = c1.equals(c2);//按住ctrl 鼠标移到equals方法上,即可查看源码
        //3.输出
        System.out.println("相等吗?"+b);
    }
}
equals方法默认的比较地址值

在这里插入图片描述

1.4 native本地方法
native修饰的方法我们称为本地方法,不是用Java写的,使用底层c/c++写的
比如:
	public native int hashCode();
1.5 扩展(equals和==的区别)【面试题】
对于基本类型:
	== 比较基本类型的数值
	equals 没有该方法

对于引用类型:
    == 比较引用类型的地址值
    equals 默认比较地址值,如果子类重写了,按照重写比较规则比较(一般会比较内容)   
1.6 Objects类
Objects类,我们称之为工具类(其内部所有的方法都是静态的)
    在Objects中有一个方法:
	public static boolean equals(Object a, Object b);
	用于判断两个对象,是否"相等",并且避免了空指针异常,该方法源码如下:
	public static boolean equals(Object a, Object b) { 
        return (a == b) || (a != null && a.equals(b)); 
    }           

第二章 Date类【重点】

2.1 Date类的介绍
:java.util.Date(不是java.sql.Date)
作用: 代表某一个时间点,可以精确到毫秒

2.2 Date类的构造方法
public Date(); 创建一个Date对象,代表当前的系统时间
public Date(long millis); 创建一个Date对象,代表距离国际基准时间millis毫秒后的那个时间
    					国际基准时间: 
							(英国): 1970.01.01 00:00:00
                            (中国): 1970.01.01 08:00:00
                                
public class TestDateDemo {
    public static void main(String[] args) {
        //1.创建一个Date对象
        Date d = new Date();
        //Fri Mar 06 10:39:24 CST 2020
        System.out.println(d);
        //2创建一个Date对象
        Date dd = new Date(0L);
        //Thu Jan 01 08:00:00 CST 1970
        System.out.println(dd); //标准时间
    }
}    

2.3 Date类的常用方法
public long getTime(); 获取当前Date对象距离基准时间的毫秒值
public void setTime(long time); 修改当前Date对象距离标准时间的毫秒值
    
public class TestDateDemo {
    public static void main(String[] args) {
        //3.常用成员方法
        Date now = new Date(); //当前的系统时间
        long time = now.getTime();
        System.out.println(time);//1583462903946

        now.setTime(1000L);
        System.out.println(now);
    }
}      

第三章 DateFormat类【重点】

3.1 DateFormat类的作用
作用: 让时间日期和具体的文本之间来回转换

格式化: Date对象 转成 时间字符串
解析:   时间字符串 转回 Date对象
    
例如:
	new Date()  -->  "2020年03月06日 18点30分26秒" 格式化
    "2020年03月06日 18点30分26秒"  --> Date对象  解析        

3.2 DateFormat类的构造方法
我们不是DateFormat(抽象类),使用的其子类(SimpleDateFormat)
public  SimpleDateFormat(String pattern);以指定的格式/模式创建SimpleDateFormat对象
这里的参数pattern表示我们想要的时间字符串的格式/模式
    想要这种格式:
			"xxxx年xx月xx日 xx:xx:xx"
    对应的pattern这么写呢?
            "yyyy年MM月dd日 HH:mm:ss"    
    我们只需要记住:
			y -- 年
            M -- 月
            d -- 日
            H -- 时
            m -- 分
            s --
3.3 DateFormat类的成员方法
public String format(Date date); 格式化方法
public Date parse(String time); 解析方法
 
public class TestDemo {
    public static void main(String[] args) throws ParseException {
        //1.创建一个SimpleDateFormat对象
        SimpleDateFormat sdf = new SimpleDateFormat("yyyy年MM月dd日 HH:mm:ss");
        //2.格式化 format
        Date now = new Date();
        String nowStr = sdf.format(now);
        System.out.println(nowStr);
        //3.解析 parse
        System.out.println("============");
        Date date = sdf.parse("2030年04月07日 12:26:20"); //异常,使用快捷键 alt+回车,再回车
        System.out.println(date);
    }
}    

第四章 Calendar类【理解】

4.1 Calendar的介绍和获取对象的方式
作用:也是表示某个时间点
Calendar的获取对象的方式:
	创建其子类GregorianCalendar类的对象(目前不使用)
    使用Calendar的静态方法【推荐方式】:
			Calendar c = Calendar.getInstance(); //就会创建一个子类对象,返回  

注意:在Calendar类中,月份(0-11)代表我们的(1-12)
 
/**
 * YEAR=2020,
 * MONTH=2,
 * DAY_OF_MONTH=6,
 * HOUR_OF_DAY=11,
 * MINUTE=30,
 * SECOND=24,
 * MILLISECOND=813
 */
public class TestCalendar {
    public static void main(String[] args) {
        //1.获取一个Calendar对象
        Calendar cc = Calendar.getInstance();
        System.out.println(cc);
    }
}    

4.2 Calendar类中常见的方法
public int get(int field); 获取日历对象中某个成员变量的值,其中参数代表该成员变量的编号!!
    
public void set(int field,int value); 修改日历对象中某个成员的值
    
public void add(int field,int value); 增加日历对象中某个成员的值    
    
public class TestCalendar {
    public static void main(String[] args) {
        //1.获取一个Calendar对象
        Calendar cc = Calendar.getInstance();
        System.out.println(cc);

        //2.获取Calendar对象中某个成员的值
        print(cc);
        //3.修改Calendar对象中某个成员的值
        cc.set(Calendar.YEAR,3000);
        cc.set(Calendar.MONTH,3);
        cc.set(Calendar.DAY_OF_MONTH,3);
        print(cc);
        //4.增加Calendar对象中某个成员的值
        cc.add(Calendar.YEAR,3000);
        cc.add(Calendar.MONTH,3);
        cc.add(Calendar.DAY_OF_MONTH,3);
        print(cc);
    }

    public static void print(Calendar cc){
        int year = cc.get(Calendar.YEAR);
        System.out.println(year);

        int month = cc.get(Calendar.MONTH);
        System.out.println(month);

        int day = cc.get(Calendar.DAY_OF_MONTH);
        System.out.println(day);
        System.out.println("==========");
    }
}
   
注意事项:
	a.Calendar类中,month从011,我们是从1-12
    b.时间日期,也是有大小之分, 时间越靠后我们认为其越大
       

第五章 Math类

5.1 Math类的介绍
Math中主要包含了一些数学运算相关的方法
Math类中这些方法都是静态的(通过类名就可以直接调用,Math当做一个工具类)  

5.2 Math类中的常见方法
public double abs(double d); //求绝对值,如果是正数,那么不变,如果负数那么把负号去掉
public double ceil(double d);//向上取整 
public double floor(double d);//向下取整
public long round(double d);// 四舍五入到整数
public double pow(double d1,double d2);//求次幂(次方)

public class TestMath {
    public static void main(String[] args) {
//        public double abs(double d); //求绝对值,如果是正数,那么不变,如果负数那么把负号去掉
        double abs = Math.abs(-3.14);
        System.out.println(abs);
//        public double ceil(double d);//向上取整
        double ceil = Math.ceil(3.1);
        System.out.println(ceil);
//        public double floor(double d);//向下取整
        double floor = Math.floor(3.9);
        System.out.println(floor);

//        public long round(double d);// 四舍五入到整数
        long round = Math.round(3.501);
        System.out.println(round);

//        public double pow(double d1,double d2);//求次幂(次方)
        //3*3*3*3
        double pow = Math.pow(3, 4);
        System.out.println(pow);
    }
}

注意:
	ceil只要有小数部分不是0,那么就向整数为进1
    floor无论如何,小数部分不要,只要整数部分
    Math.ceil(3.0); ===> 3.0
	Math.floor(3.0); ===> 3.0       

关于负数的ceil和floor

在这里插入图片描述

第六章 System

6.1 System类的介绍
System类中包含几个静态的变量和静态的方法,并且该类是不能创建对象的
经过我们对System类源码的研究,发现System类的构造被私有化了
    public final class System {
        /** Don't let anyone instantiate this class */
        private System() {
        }
    }    

6.2 System类的常见方法
public static void exit(int status); 退出JVM虚拟机,按照惯例,参数写0即可!!
    
public class TestSystem {
    public static void main(String[] args) {
        //1.试图创建一个System对象
//        System s = new System(); //报错! 因为System的构造私有化了
        //2.exit
        for (int i = 0; i < 10; i++) {
            System.out.println("我爱Java"+i);
            //退出JVM,整个Java程序都会结束
            System.exit(0);
//            break; //结束当前的循环,如果循环后面还有代码可以继续执行
        }

        System.out.println(".....");
    }
}

public static long currentTimeMillis(); 获取当前系统之间的毫秒值(距离基准时间的毫秒值)
    
public class TestSystem02 {
    public static void main(String[] args) {
        //1.获取当前系统时间的毫秒值
        //long millis = System.currentTimeMillis();
        //System.out.println(millis);
        //2. String StringBuilder  用于字符串拼接的性能测试

        long start = System.currentTimeMillis();

        //5万次的String拼接 耗时8085毫秒 8秒多
//        String s = "";
//        for (int i = 0; i < 50000; i++) {
//            s += i;
//        }
        //5万次的StringBuilder拼接 耗时27毫秒 0.027秒
        StringBuilder sb = new StringBuilder();
        for (int i = 0; i < 50000; i++) {
            sb.append(i);
        }

        long end = System.currentTimeMillis();
        System.out.println("耗时"+(end-start)+"毫秒");
        //算法: 空间复杂度(占用的内存) 时间复杂度(运行花费的时间)
    }
}    

总结
1.Object
    所有类父类
    toString: 默认返回对象的字符串表示,包名.类名@地址值
        	  开发中我们会重写toString,返回对象的内容(alt+insert自动生成)
    		  注意: 实际上我们不需要手动调用toString方法,
					因为我们在使用对象时,编译器会自动调用toString()方法
    equals: 默认比较两个对象的地址值
        	开发中我们也会重写equals,比较两个对象的内容(属性值)
2.Date和DateFormat
     构造方法
     public Date(); // 当前系统时间
	 public Date(long millis); //距离基准时间milllis毫秒后的那个时间

	 成员方法
     public long getTime();//获取当前Date对象距离基准时间的毫秒值 
	 public void getTime(long millis);//修改当前Date对象距离基准时间的毫秒值

	 SimpleDateFormat(子类) extends DateFormat(抽象类)
         
     构造方法:
		public SimpleDateFormat(String 模式/格式); //模式 "yyyy-MM-dd HH:mm:ss"
             
	 成员方法:
		格式化: public String format(Date date);
        解 析: public Date parse(String time);
 3.Calendar
     获取对象:
		Calendar c = Calendar.getInstance();//返回Calendar的子类对象
     成员方法:
		public void get(int field);
		public void set(int field,int value);
		public void add(int field,int value);
4.Math
    Math类中方法都是静态的
    public static double abs(double d);
    public static double ceil(double d);
    public static double floor(double d);
    public static long round(double d);
    public static double pow(double d1,double d2)
        
6.System
    System类中方法都是静态的    
    public static void exit(0);//退出JVM
	public static long currentTimeMillis();//获取当前时间的毫秒值(用于计算某段代码的运行时间)
        

发布了23 篇原创文章 · 获赞 0 · 访问量 1150

猜你喜欢

转载自blog.csdn.net/qq_44845814/article/details/104801753