java基础09(形参和返回值，内部类，“==“与equals的区别,Math,System,Object,Arrays,包装类，日期类)

形参和返回值

类名作为形参和返回值

• 方法的形参是类名。实际需要的是该类的对象public void classParam(Animal animal){...}
• 方法的返回值是类名，实际返回的是该类的对象public Animal returnClass(){...}

抽象类名作为形参和返回值

• 方法的形参是抽象类名。实际需要的是该抽象类的子类对象
• 方法的返回值是抽象类名，实际返回的是该抽象类的子类对象

接口名作为形参和返回值

• 方法的形参是接口名。实际需要的是该接口的实现类对象
• 方法的返回值是接口名，实际返回的是该接口的实现类对象

内部类

内部类就是在一个类中定义一个类,内部类作为外部类的一个成员，并且依附于外部类而存在。
格式：

/*内部类*/
public class demo {
    class innerdemo{
        
    }
}

内部类的访问特点

• 内部类可以直接访问外部类的所有成员，包括私有。内部类中不能有静态声明
• 外部类想要访问内部类的成员，必须创建对象

/*内部类*/
public class Outer {
    private int num = 10;
    private int c = 10;
    //内部类
    public class Inner{
        private  int b = 20;
        private int num = 100;
        public void show(){
            //内部类访问外部类的成员
            System.out.println(c);
            System.out.println(Outer.this.num);
        }
    }
    public void showInner() {
        //外部类访问内部类成员
        Inner inner = new Inner();//创建内部类对象
        System.out.println(inner.b);
        inner.show();
    }
}

成员内部类

按照内部类在类中定义的位置的不同，可以分为两种:

• 在类的成员位置，成员内部类
• 在类的局部位置，局部内部类，也称方法内部类
  成员内部类，外界如何创建使用？格式：外部类名.内部类名 对象名 = new 外部类名().new 内部类名();

Outer.Inner inner = new Outer().new Inner();

内部类一般用private私有化，此时，在外部类中新建方法，在方法中新建内部类对象，测试类直接新建外部类对象，调用方法即可

局部/方法内部类

局部内部类是在方法中定义的类，所以外界是无法直接访问的，需要在外部类中创建方法，方法中创建对象使用，该类可以直接访问外部类的成员，也可以访问方法内的局部变量

public class Outer {
    //成员变量，成员方法
    private int num = 10;
    public void method(){
        //创建局部/方法内部类
        class Inner{
            public void show(){
                System.out.println(num);
            }
        }
        //创建局部内部类对象
        Inner inner = new Inner();
        inner.show();
    }
}

/*测试类*/
public class Test {
    public static void main(String[] args) {
        //创建外部类对象,访问局部内部类成员
        Outer outer = new Outer();
        outer.method();

    }
}

匿名内部类

匿名内部类是局部内部类的一种特殊形式，前提：存在一个类或接口，该类可以是抽象的也可以是具体的，本质是继承该类或实现了接口的子类匿名对象,格式

/*匿名内部类*/
public class Outer {
    public void method(){
    new Inner(){
            //重写方法
            @Override
            public void 方法名() {
                System.out.println("匿名内部类");
            }
        }.方法名();
    }

}

/*匿名内部类*/
public class Outer {
    public void method(){
            //匿名内部类,写法一
/*        new Inner(){
            //重写方法
            @Override
            public void show() {
                System.out.println("匿名内部类");
            }
        }.show();*/
        //匿名内部类，写法二
       Inner inner =  new Inner(){
            //重写方法
            @Override
            public void show() {
                System.out.println("匿名内部类");
            }
        };
       inner.show();
       inner.show();
        inner.show();
    }

}

匿名内部类在开发中利用

public class JumpDemo {
    public static void main(String[] args) {
        //创建JumpOperate对象，调用method方法
        JumpOperate jumpOperate = new JumpOperate();
     /*   //方式一，创建接口实现类，创建接口实现类对象
        Jump jump = new JumpImp();
        jumpOperate.method(jump);*/
        //方式二，匿名内部类
        jumpOperate.method(new Jump(){
            @Override
            public void jump() {
                System.out.println("跳高");
            }
        });
        jumpOperate.method(new Jump(){
            @Override
            public void jump() {
                System.out.println("跳高1米");
            }
        });
        jumpOperate.method(new Jump(){
            @Override
            public void jump() {
                System.out.println("跳高2米");
            }
        });
    }
}

常见API

Math

Math类没有构造方法，里面的成员都是静态，可以通过类名直接访问

方法名	说明
public static int abs(int a)	返回参数a的绝对值
public static double ceil(double a)	返回不小于参数a的整数
public static double floor(double a)	返回不大于参数a的整数
public static int round(float a)	按照四舍五入返回最接近参数a的整数
public static int max(int a,int b)	返回整数a和整数b中的较大值
public static int min(int a,int b)	返回整数a和整数b中的较小值
public static double pow(double a,double b)	返回a的b次幂的值
public static double random()	返回[0.0,1.0)中的一个随机数

/*Math类常见方法*/
public class MathDemo {
    public static void main(String[] args) {
        //绝对值
        System.out.println("返回-10的绝对值"+Math.abs(-10));//10
        //不小于参数的整数
        System.out.println("返回不小于10.2的整数"+Math.ceil(10.2));//11.0
        //不大于参数的整数
        System.out.println("返回不大于10.2的整数"+Math.floor(10.2));//10.0
        //四舍五入整数
        System.out.println("返回最接近14.2的四舍五入整数值"+Math.round(14.2));//14
        System.out.println("返回最接近14的四舍五入整数值"+Math.round(14));//14
        //比较两个整数的较大值
        System.out.println("返回10与5中的较大值"+Math.max(10,5));//10
        //比较两个整数的较小值
        System.out.println("返回10与5中的较小值"+Math.min(10,5));//5
        //返回a的b次幂
        System.out.println("返回2的3次幂"+Math.pow(2,3));//8.0
        //返回一个随机数,[0.0,1.0)
        int a = (int)(Math.random()*100);
        int b = a + 1;
        System.out.println("返回一个0到99随机数的整数部分"+a);//
        System.out.println("返回一个1到100随机数的整数部分"+b);//
    }
}

System

System类包含几个有用的字段和方法，它不能被实例化

方法名	说明
public static void exit(int status)	终止当前运行的java虚拟机，非零表示终止异常
public static long currentTimeMillis()	返回当前时间，以毫秒为单位

public class SystemDemo {
    public static void main(String[] args) {
        //public static long currentTimeMillis()	返回当前时间，以毫秒为单位
        System.out.println(System.currentTimeMillis() *1.0 / 1000 / 60 / 60 / 24 / 365 + "年");//50.99250268042872年
        //public static void exit(int status)	终止当前运行的java虚拟机，非零表示终止异常
        System.exit(0);//Process finished with exit code 0
    }

}

Object

Object是类层级结构的根，每个类都可以将Object作为超类，所有类都直接或间接继承自该类

方法名	说明
public String toString()	返回对象的字符串表示形式，建议所有子类重写该方法，自动生成
public boolean equals(Object obj)	默认比较对象地址是否相等，重写可以比较内容，自动生成

/*查看方法的源码，选中方法，按下ctrl+B
 * 建议所有子类都重写toString()方法，alt+insert*/
public class ObjectDemo {
    public static void main(String[] args) {
        Student student = new Student();
        student.setName("周杰伦");
        student.setAge(44);

        Student student1 = new Student();
        student.setName("周杰伦");
        student.setAge(44);

        System.out.println(student);//重写toString()方法前:com.object.Student@1b6d3586;重写toString()方法后:Student{name='周杰伦', age=44}
        System.out.println(student == student1);//false
        System.out.println(student.equals(student1));//true
        /* public void println(Object x) {
        String s = String.valueOf(x);
        synchronized (this) {
            print(s);
            newLine();
        }
    }*//*   public static String valueOf(Object obj) {
        return (obj == null) ? "null" : obj.toString();
    }*/
        /* public String toString() {
        return getClass().getName() + "@" + Integer.toHexString(hashCode());
    }*/
    }
}

"=="与equals的区别

"=="比较基本数据类型的时候，比较的是值是否相等；比较引用数据类型的时候，比较的是地址值是否相等
equals默认比较对象地址是否相等，重写可以比较对象内容是否相同，String类中重写了equals方法

Arrays

Arrays类中包含了对数组操作的各种方法

方法名	说明
public static String toString(int[] arr)	返回指定数组的内容的字符串形式
public static void sort(int[] arr)	按照数字顺序排列指定的数组

import java.util.Arrays;

public class ArraysDemo {
    public static void main(String[] args) {
        int[] arr = {24,16,53,23,65,86};
        //public static String toString(int[] arr)	返回指定数组的内容的字符串形式
        System.out.println("排序前"+Arrays.toString(arr));//排序前[24, 16, 53, 23, 65, 86]
        //public static void sort(int[] arr)	按照数字顺序排列指定的数组
        Arrays.sort(arr);
        System.out.println("排序后"+Arrays.toString(arr));//排序后[16, 23, 24, 53, 65, 86]
    }
}

工具类(System,Math,Arrays)设计思想：

• 构造方法用private修饰，防止外界创建对象
• 成员方法用public static修饰，通过类名直接访问

冒泡排序

• 如果有n个数据进行比较，则需要比较n-1次
• 每次比较后，下一次的比较就会少一个数据参加

基本类型包装类

Integer类的概述和使用

Integer包装一个对象中原始数据int的值

方法名	说明
public Integer(int value)	根据Int值创建Integer对象(已过时)
public Integer(String s)	根据String值创建Integer对象(已过时)
public static Integer valueOf(int i)	返回表示指定的int值的Integer实例
public static Integer valueOf(String s)	返回一个保存指定值的Integer对象String
注意：以上方法均支持单字符(‘a’,‘男’)，会输出字符对应的ASCII码值

/*public Integer(int value)	根据Int值创建Integer对象(已过时)
public Integer(String s)	根据String值创建Integer对象(已过时)
public static Integer valueOf(int i)	返回表示指定的int值的Integer实例
public static Integer valueOf(String s)	返回一个保存指定值的Integer对象String */
public class IntegerDemo {
    public static void main(String[] args) {
        //public Integer(int value)	根据Int值创建Integer对象(已过时)
        Integer integer = new Integer(100);
        System.out.println(integer);
        //public Integer(String s)	根据String值创建Integer对象(已过时)
        Integer integer1 = new Integer("100");
        //Integer integer2 = new Integer("abc");//NumberFormatException
        Integer integer3 = new Integer('男');//30007
        System.out.println(integer3);//97
        System.out.println(integer1);
        //public static Integer valueOf(int i)	返回表示指定的int值的Integer实例
        Integer integer4 = Integer.valueOf(100);
        System.out.println(integer4);
        //public static Integer valueOf(String s)	返回一个保存指定值的Integer对象String
        Integer integer5 = Integer.valueOf("100");
        System.out.println(integer5);
        Integer integer6 = Integer.valueOf('b');//98
        System.out.println(integer6);
    }
}

int和String的相互转换

• int -> String,String类，public static String valueOf(int a)
• String -> int，public static int parseInt(String s)

```java
/*int和String的相互转换*/
public class IntegerDemo1 {
    public static void main(String[] args) {
        //int转为String
        int a = 123;
        //方式一
        String s = ""+ a;
        System.out.println(s);
        //方式二 public static String valueOf(int a)
        String s1 = String.valueOf(a);
        //String转为int
        //方式一，String->Integer->int
        String s2 = "123";
        Integer integer = Integer.valueOf(s1);
        //public int intValue()
        System.out.println(integer.intValue());
        //方式二 public static int parseInt(String s)
        System.out.println(Integer.parseInt(s2));
    }
}

自动装箱和拆箱

• 装箱：把基本数据类型转换为包装类类型
• 拆箱：把包装类类型转换为基本数据类型

/*拆箱和装箱*/
public class Demo2 {
    public static void main(String[] args) {
        //装箱：把基本数据类型转换为包装类类型
        int i = 100;
        Integer integer = Integer.valueOf(i);//装箱
        integer = 100;//自动装箱，系统做了Integer.valueOf(i)操作
        //拆箱：把包装类类型转换为基本数据类型
        int a = integer.intValue() + 200;//拆箱
        System.out.println(integer+200);//自动拆箱
    }
}

注意：在使用包装类型的时候，只要有操作，必须先判断是否为null，建议只要是对象，使用前都先判断是否为null

日期类

Date类

方法名	说明
public Date()	分配一个Date对象，并初始化，以便它代表分配的当前时间，精确到毫秒
public Date(long date)	分配一个Date对象，并将其初始化为表示从标准基准时间起指定的毫秒数
public long getTime()	获取的是日期对象，从1970年1月1日00:00:00到现在的毫秒数
public void setTime()	设置时间，给的是毫秒值

/*Date类的构造方法和常用方法*/
import java.util.Date;

public class DateDemo {
    public static void main(String[] args) {
        //构造方法 public Date()
        Date date = new Date();
        System.out.println(date);//Wed Dec 16 20:43:45 CST 2020
        //public long getTime()
        System.out.println(date.getTime()/ 1000 / 60 / 60 / 24 /365+"年");
        //public void setTime()
        long time = 1000*60*60;
        date.setTime(time);
        System.out.println(date);//
        //构造方法 public Date(long date)
        Date date1 = new Date(1000*60*60);
        System.out.println(date1);//Thu Jan 01 09:00:00 CST 1970
    }
}

SimpleDateFormat类

SimpleDateFormat是一个具体的类，用于区域设置敏感的方法格式化和解析日期，重点是日期格式化和解析
常用的模式字母及对应关系：

• y----------年
• M----------月
• d----------日
• H----------时
• m----------分
• s----------秒

方法名	说明
public SimpleDateFormat()	构造一个SimpleDateFormat，使用默认模式和日期格式
public SimpleDateFormat(String pattern)	构造一个SimpleDateFormat，使用给定模式和默认的日期格式

1. 格式化，public final String format(Date date),将日期格式化为日期/时间格式的字符串
2. 解析,public Date parse(String source)，从给定字符串的开始解析文本以生日期

import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.Date;

/*public SimpleDateFormat()	构造一个SimpleDateFormat，使用默认模式和日期格式
public SimpleDateFormat(String pattern)	构造一个SimpleDateFormat，使用给定模式和默认的日期格式
格式化，public final String format(Date date),将日期格式化为日期/的格式
解析,public Date parse(String source)，从给定字符串的开始解析文本以生日期*/
public class SimpleDateFormatDemo {
    public static void main(String[] args) throws ParseException {
        //public SimpleDateFormat()	构造一个SimpleDateFormat，使用默认模式和日期格式
        SimpleDateFormat simpleDateFormat = new SimpleDateFormat();
        Date date = new Date();
        //格式化，public final String format(Date date),将日期格式化为日期/时间格式的字符串
        System.out.println(simpleDateFormat.format(date));//20-12-16 下午9:36
        //public SimpleDateFormat(String pattern)	构造一个SimpleDateFormat，使用给定模式和默认的日期格式
        SimpleDateFormat simpleDateFormat1 = new SimpleDateFormat("yyyy年MM月dd日 HH:mm:ss");
        String s = "2020年12月15日 8:00:00";
        System.out.println(simpleDateFormat1.parse(s));//Tue Dec 15 08:00:00 CST 2020
    }
}

Calendar类

方法名	说明
public int get(int field)	返回给定日历字段的值
public abstract void add(int field,int amount)	根据日历的规则，将指定的时间量添加或减去给定的日历字段
public final void set(int year,int month,int date)	设置当前日历的年月日

/*Calendar类常用方法*/
import java.util.Calendar;

public class CalendarDemo {
    public static void main(String[] args) {
        //获取日历对象
        Calendar calendar = Calendar.getInstance();
        //public int get(int field)	返回给定日历字段的值
        int year = calendar.get(Calendar.YEAR);
        int month = calendar.get(Calendar.MONTH)+1;
        int day = calendar.get(Calendar.DATE);
        System.out.println("现在是："+year+"年"+month+"月"+day+"日");
        //public abstract void add(int field,int amount)	根据日历的规则，将指定的时间量添加或减去给定的日历字段
        Calendar calendar1 = Calendar.getInstance();
        calendar1.add(Calendar.YEAR,-2);
        int year1 = calendar1.get(Calendar.YEAR);
        int month1 = calendar1.get(Calendar.MONTH)+1;
        int day1 = calendar1.get(Calendar.DATE);

        System.out.println("两年前是："+year1+"年"+month1+"月"+day1+"日");
        //public final void set(int year,int month,int date)	设置当前日历的年月日
        Calendar calendar2 = Calendar.getInstance();
        calendar2.set(2020,4,20);
        int year2 = calendar2.get(Calendar.YEAR);
        int month2 = calendar2.get(Calendar.MONTH)+1;
        int day2 = calendar2.get(Calendar.DATE);
        System.out.println(year2+"年"+month2+"月"+day2+"日");
    }
}