Java Objec和包装类

零、复习昨日

修饰符	abstract	interface
是不是类	类	接口
属性	正常属性	没有属性，全部是常量，默认被public static final修饰
方法	可以有正常方法，也可以有抽象类	全部都是抽象方法，public abstract修饰
构造方法	可以有，但是不能创建对象	不能有
子类	extends 抽象类，单继承	implements 接口，多实现

相同：
都可以当作数据类型来用，用来接收子类类型
子类无论继承抽象类，还是实现接口都要强制重写父类的抽象方法

二、代码块[了解]

代码块，就是一对儿 {} 包裹的代码就是代码块
特殊的代码块
静态代码块：随着类加载而执行，内部的代码在内存中只有一份
public class Code{ static{ System,out,println("静态代码块"); } public static void main(String[] args){ Code code = null； } }
构造代码块:构造代码块会在每次构造方法执行前执行； 用于抽取构造方法中重复代码，在每个构造方法执行前都会执行一次。
{ System,out,println("构造代码块"); }
局部代码块：局部代码块，可以及时释放资源
public void test(){ System,out,println("方法内1"); { int a = 1; System,out,println(a); } System,out,println("方法内2"); }

public class Code{

    /**
     * 随着类加载而执行
     * 内部的代码在内存只有一份
     */
    static {
        System.out.println("静态代码块" );
    }

    /**
     * 构造代码块会在每次的构造方法执行前执行
     * 用于抽取构造方法中重复代码,在每个构造方法执行前都能执行
     */
    {
        System.out.println("构造代码块" );
    }

    public void test() {
        System.out.println("方法内1" );
        int b = 1;
        /**
         * 局部代码块,及时释放资源
         */
        {
            int a = 1;
            System.out.println(a );
            System.out.println("局部代码块" );
        }

        // a变量无法使用
        // System.out.println("方法内2" + a);
        System.out.println(b );
    }

    public Code(){
        System.out.println("无参构造" );
    }

    public Code(int a){
        System.out.println("有参构造" );
    }
    public static void main(String[] args) {
        Code code = new Code();
        // Code code2 = new Code(1);
        code.test();
    }
}

扩展知识,有时间自己看: 内部类(成员内部类,静态内部类,.....)

三、API

API:Application Programing Interface 应用程序编程接口
API 其实就是JDK的说明书，通过API学习常用Java类

四、Object

ps：java.lang包下的资源使用是不需要导包

类Object是类层次结构的根类。每个类都使用Object作为超类。所有对象（包括数组）都实现这个类的方法。

Object类是所有类的父类，所有的对象都可以使用Object类的方法，隐式继承Object

构造方法

Object有构造方法，可以创建对象

方法

    public static void main(String[] args) {
        // equals 底层使用==判断地址是否相等
        boolean equals = o1.equals(o2);
        System.out.println(equals);

        /**
         * 大部分时候判断对象地址没有意义,因为每次new都会有新地址,肯定不一样
         * 且项目开发中,大多数时候认为对象的属性完全一致则认为是同一对象,即相等
         * 即,equals应该判断对象属性是否相等,而不是地址是否相等
         * 所以!!!! 所有子类都会重写equals用于判断对象属性内容是否一致!
         * ----------------------------------------------
         * 面试题: == 和 equals有什么区别
         * 1. == 是运算符,equals是方法
         * 2. Object中的equals就是==,判断地址
         * 3.如果子类重写了equals,那么就是判断内容相等而不是地址
         */
        Student s1 = new Student(18,"老黑");
        Student s2 = new Student( 18,"老黑");

        System.out.println(s1.equals(s2));

    }

    public static void main(String[] args) {
        Student s1 = new Student(18,"老黑");
        Student s2 = new Student( 18,"老黑");

        // 这就是内存的地址值
        System.out.println(s1.hashCode() );
        // 对象调用toString会打印包名+类名+@+变化后的hashcode值
        System.out.println(s1.toString() );
        // 其实直接输出对象,默认调用toString
        System.out.println(s1);

        // 输出对象地址其实没啥意义,一般打印对象内容
        // 基本上所有子类都会重写toString,打印内容
        System.out.println(s1 );
    }

equals：大部分时候判断对象地址没有意义，因为每次new都会有新地址，肯定不一样，且项目开发中，大多数时候认为对象的属性完全一直测认为是同一对象，即相等所以equals应该判断对象属性是否相等，而不是地址是否相等。所以所有子类都会重写equals用于判断对象属性内容是否一致！

==面试题： == 和 equals有什么区别？==
== 是运算符，equals是方法
Object中的equals就是 == ，判断地址
如果子类重写了equals，那么就是判断内容相等而不是地址

五、包装类

将8个基本类型包装成了对应的引用类型，变成包装类。

基本类型	包装类
byte	Byte
short	Short
int	Integer
long	Long
float	Float
double	Double
char	Character
boolean	Boolean

因为基本类型功能单一，包装成类，那么就会有对应的属性、方法、功能变得更多更好用。
最主要的用处：用于String和对应基本类型转换

5.1 Integer

通过查看API得知,数字相关类型,内部的属性和构造方法以及方法都和Integer差不多,就以Integer为例

Integer 类在对象中包装了一个基本类型 int的值。Integer类型的对象包含一个 int类型的字段。
此外，该类提供了多个方法，能在 int类型和 String类型之间互相转换，还提供了处理 int类型时非常有用的其他一些常量和方法。

属性

构造方法
Integer(int value)
构造一个新分配的 Integer 对象，它表示指定的 int 值。
Integer(String s)
构造一个新分配的 Integer 对象，它表示 String 参数所指示的 int 值。

        // 将基本类型变成包装类
        Integer i1 = new Integer(1);
        System.out.println(i1);

        // 能将纯数字字符串变成数字
        Integer i2 = new Integer("222");
        System.out.println(i2+2 );

方法
int intValue()
以 int 类型返回该 Integer 的值。
== static int parseInt(String s)==
将字符串参数作为有符号的十进制整数进行解析。
String toString()
返回一个表示该 Integer 值的 String 对象。
static String toString(int i)
返回一个表示指定整数的 String 对象。
static Integer valueOf(int i)
返回一个表示指定的 int 值的 Integer 实例。
static Integer valueOf(String s)
返回保存指定的 String 的值的 Integer 对象。

       // 包装类中取出基本类型的值
        int i = i1.intValue( );
        System.out.println(i + 222 );

        // parseInt() 将纯数字字符串解析为对应int类型
        // 其他基本包装类都有类似parseXxx
        int j = Integer.parseInt("333");
        System.out.println(j + 1 );
		
        // 将数字变字符串返回 
        String s = Integer.toString(22);
        System.out.println(s + 22 );

        // 将基本类型int变为包装类返回
        Integer integer = Integer.valueOf(111);
        // 将字符串变包装类对象返回
        Integer integer1 = Integer.valueOf("111");
        System.out.println(integer1+ 222 );

        // Integer+""变字符串
        System.out.println(i1+"" + 1 );

5.2 自动装箱&拆箱

以前将基本类型装箱成包装类
Integer i = new Integer(1);
现在推荐自动装箱的写法
Integer i = 1;

以前将从包装类中取出基本类型的值
int i = integer.intValue();
现在推荐自动拆箱的写法
int i = integer;

5.3 Character

char的包装类

1、static boolean isDigit(char ch)

确定指定字符是否为数字。

2、static boolean isLetter(char ch)

确定指定字符是否为字母。

3、static boolean isLowerCase(char ch)

确定指定字符是否为小写字母。

4、static boolean isUpperCase(char ch)

确定指定字符是否为大写字母

5、static char toLowerCase(char ch)

使用取自UnicodeData 文件的大小写映射信息将字符参数转换为小写

6、static char toUpperCase(char ch)

使用取自UnicodeData 文件的大小写映射信息将字符参数转换为大写

  public static void main(String[] args) {   		System.out.println(Character.isDigit('a'));
    System.out.println(Character.isDigit('1'));
    System.out.println(Character.isLetter('a') );
    System.out.println(Character.isLetter('1') );
    System.out.println(Character.isLowerCase('a') );
    System.out.println(Character.isUpperCase('a') );

    char a = Character.toLowerCase('A');
    System.out.println(a );

}

六、数学和随机

6.1 Math

Math提供了一系列数学运算，如初等函数、对数、平方根和三角函数。
方法都是静态的，直接通过类名调用，将构造方法私有了,不能创建对象的!

1、static int abs(int a)
返回 int 值的绝对值。
2、static double ceil(double a)
返回最小的（最接近负无穷大）double 值，该值大于等于参数，并等于某个整数。
3、static double floor(double a)
返回最大的（最接近正无穷大）double 值，该值小于等于参数，并等于某个整数。
4、static double max(double a, double b)
返回两个 double 值中较大的一个。
5、static double pow(double a, double b)
返回第一个参数的第二个参数次幂的值。
6、static double random()
返回带正号的 double 值，该值大于等于 0.0 且小于 1.0。
7、static long round(double a)
返回最接近参数的 long。

    public static void main(String[] args) {
        // static int abs(int a)
        // 返回 int 值的绝对值。

        System.out.println(Math.abs(-1) );

        // static double ceil(double a)
        // 返回最小的（最接近负无穷大）double 值，该值大于等于参数，并等于某个整数。
        System.out.println(Math.ceil(-11.2) );

        // static double floor(double a)
        // 返回最大的（最接近正无穷大）double 值，该值小于等于参数，并等于某个整数。
        System.out.println(Math.floor(11.2) );

        // static double max(double a, double b)
        // 返回两个 double 值中较大的一个。
        System.out.println(Math.max(11,2) );

        // static double pow(double a, double b)
        // 返回第一个参数的第二个参数次幂的值。
        System.out.println(Math.pow(2,0.5) );

        // static double random()
        // 返回带正号的 double 值，该值大于等于 0.0 且小于 1.0。
        System.out.println(Math.random() );

        System.out.println((int)(Math.random()*10) );

        // static long round(double a)
        // 返回最接近参数的 long。(四舍五入)
        System.out.println(Math.round(4.4) );

        System.out.println(Math.round(Math.random() * 10) );
    }

6.2 Random

随机数生成器.

构造方法
Random()
创建一个新的随机数生成器。
Random(long seed)
使用单个 long 种子创建一个新的随机数生成器。 (后续创建出的随机数固定)

方法
int nextInt()
返回下一个伪随机数，它是此随机数生成器的序列中均匀分布的 int 值。 (正负21亿之间随机)
int nextInt(int n)
返回一个伪随机数，它是取自此随机数生成器序列的、在 0（包括）和指定值（不包括）之间均匀分布的 int 值。