JAVA类与对象（3）

JAVA类与对象

• 内部类和常用类
  内部类、Object类、String类、包装类、BigDecimal类
• 外部类
  创建外部类的匿名对象：new Outer().speak();
  1.匿名对象是指没有名字的对象，只能使用一次
• 内部类
  概念：在一个类的内部再定义一个完整的类。
  特点：编译之后可形成独立的字节码文件，可以访问外部类的私有成员而不破坏封装。
  分为：成员内部类、静态内部类、局部内部类、匿名内部类
• 成员内部类
  在类的内部定义，和实例变量、实例方法同级别的类，作为外部类的实例部分，创建时必须依赖外部对象。如下：Outer.Inner in = new Outer().new Inner();
  注：
  1.在内部类与外部类有重名属性时，会优先访问内部类属性，要访问外部类的同名属性时，需加上外部类名.this。
  2.成员内部类中不能定义静态成员，只有将其设置为静态内部类才能添加静态方法 。
  3.外部类不能直接使用内部类的资源
  4.外部类如果想要使用内部类的资源，需要先创建内部类的对象，通过内部类对象来调用内部类的资源Inner in = new Inner();
  5.内部类可以直接使用外部类的资源，私有成员也可以
  6.如果成员内部类被private修饰的解决方法

class Outer2{
    public void getInner2(){
        Inner2 inner2 =new Inner2();
        inner2.eat();
    }

    private class Inner2{
        public void eat(){
            System.out.println("我是私有成员内部类的方法eat");
        }
    }
}

• 静态内部类
  当内部类被static修饰时，new Outer()会报错，所以我们无需创建外部类对象，可通过类名找到内部类，直接创建静态内部类的对象即可。调用方式：

 //普通方式
Outer3.Inner3 oi3 = new Outer3.Inner3();
//匿名内部类方式
new Outer3.Inner3().find();
//访问静态内部类的静态方法：链式加载
Outer3.Inner3.delete();

• 局部内部类
  定义在外部类方法中，作用范围和创建方法仅限于当前方法。
  注意：直接创建外部类对象调用show()是无法出发内部类的功能的，需要在外部类中创建内部类对象并且调用内部类的功能才能触发

class Outer4{
    public void show(){
        System.out.println("我是外部类的普通方法show");

        class Inner4{
            int sum=22;
            String name;
            public void eat(){
                System.out.println("我是局部内部类的普通方法eat");
            }
        }

        //使用局部内部类的功能
        Inner4 i4 = new Inner4();
        i4.eat();
    }
}

• 匿名内部类
  1.没有类名的局部内部类（所有特征都与局部内部类相同）。
  2.必须继承一个父类或实现一个接口。
  3.匿名对象只能使用一次，一次只能调用一个方法

package cn.tedu.innerclass;

public class TestInner5 {
    public static void main(String[] args) {
        //相当于3合1：new Inter1()---创建匿名对象
        //{方法的实现}
        //.save()
        new Inter1(){
            @Override
            public void save() {
                System.out.println("正在保存");
            }

            @Override
            public void get() {
                System.out.println("正在获取");
            }
        }.save();


    }
}

interface Inter1{
    void save();
    void get();
}

• Object类
  1.超类、基类，所有类的直接或间接父类，位于继承树的最顶层。
  2.任何类若没有写Extends，都默认为继承Object类，否则为间接继承
  3.Object中的方法是所有对象都具备的方法。
  4.Object类型可以存储任何对象，作为参数可接受任何对象，作为函数可返回任何对象。
  getClass()方法：
  public final class<?> getClass(){}，返回引用中存储的实际的对象类型，用于判断两个引用中实际存储对象类型是否一致。
  hashCode()方法：
  public int hashCode(){}，返回该对象的哈希值，根据地址、字符串、数字计算出来的int类型的值。
  toString()方法：
  public String toString(){}，返回该对象的字符串表示，如：展示对象各个属性值。
  equals()方法：
  用于判断两个值是否相同，返回布尔类型，本方法底层的判断逻辑是“==”比较，比较的是左右两边的地址值。
  重写之前是通过等等比较的，比较的是值，如果是引用类型（比如自定义的类），比较的是对象名，也就是地址值。
  重写之后的效果取决于怎么重写的
  finalize()方法：
  当对象被判定为垃圾对象时，由JVM自动调用该方法，用于标记垃圾对象，进入回收序列，其中垃圾对象（没有有效引用指向此对象时，为垃圾对象），垃圾回收（由GC销毁垃圾对象），自动回收机制（JVM内存空间耗尽，自动回收垃圾对象释放存储空间），手动回收机制（通过System.gc（）通知JVM回收）。
• 包装类
  1.基本数据类型所对应的引用数据类型。
  2.Object可统一所有数据，包装默认值是null。
  3.Integer有一个高效的效果，数据在（-128-127）范围内，相同的数据只会存一次，后续使用的都是之前存入的数据（a.范围之内；b.Integer；c.valueOf），并且有且仅有这个有高效效果，Double是没有的
  4.Integer包装对象名.parseInt（参数）作用是把String类型的数据转为int；
  Double包装对象名.parseDouble（参数）作用是把String类型的数据转为double；
  
• 自动装箱与自动拆箱
  1.自动装箱会将基本类型int包装成Integer，然后交给Integer类型的引用类型变量保存，自动装箱的底层代码：Integer.valueOf(参数)，方向：int ——> Integer
  2.编译器会自动把包装类型的对象拆掉箱子变成基本的数据，然后交给基本类型int的变量i4来保存，自动拆箱底层代码：int型变量名.intValue()，方向：Integer——>int

package cn.tedu.API;

public class TestNumber2 {
    Integer i1 = new Integer(127);
    Integer i2 = Integer.valueOf(127);
    //自动装箱
    Integer i3=5;
    //自动拆箱
    int i4=i1;
}

• String类
  1.字符串是常量，创建之后不可改变。
  2.字符串字面值存储在字符串池中，可以共享。
  3.注意常量池的概念，高效创建于普通创建的区别
  4.Object类中的equals方法的默认实现是通过等等比较的。但是String类把它重写了，重写之后不再按照等等比较，而是比较两个字符串的具体内容。也就是只要其内容一致，equals就返回true

String name="aaa";  //存储在字符串池中
name="bbb";  //这里的name并没有赋值，而是重新开辟了个空间。
String name2 = new String("aaa");  //产生两个对象，堆和池各一个

char[] name2 = {'C','o','o','l'};
        String str1 = new String(name2);
        String str2 = new String(name2);

        String str3 = "Cool";
        String str4 = "Cool";
        String str5 = "ool";


        System.out.println(str1 == str3);//false，一个在堆里，一个在堆中常量池
        System.out.println(str1 == str2);//false，两个不同的对象，地址值不同
        System.out.println(str3 == str4);//true，都在堆中常量池，并且指向同一个，所以地址值相同
        System.out.println(str3 == str5);//false，都在堆中常量池，但没有指向同一个，指向地址值
		System.out.println(str1.equals(str3));//true
        System.out.println(str1.equals(str2));//true
        System.out.println(str3.equals(str5));//false

• String常用方法
  串名.length()： 返回字符串长度。
  串名.charAt(下标)： 根据下标获取字符。
  串名.concat(字符串) ：拼接字符串，只在打印时生效，不影响原字符串
  串名.substring(index1，index2)：一个下标时表示从什么位置开始截取字符串；两个下标时表示指定下标范围截取字符串，前闭后开
  String.value(参数)：把该参数转为字符串
  public boolean contains(String str)：判断当前字符中是否包含str。
  public char[] toCharArray()：将字符串转成数组。
  串名.indexOf(String str)： 返回str在字符串中首次出现的下标，不存在则返回-1。
  串名.lastIndexOf(String str)： 返回str在字符串中最后出现的下标。
  串名.trim()： 去掉字符串前后的空格。
  串名.toUpperCase()： 将小写转成大写。
  串名.toLowerCase()： 将大写转成小写。
  串名.startsWith(String str)： 判断字符串是否以str开头。
  串名.endsWith(String str)： 判断字符串是否以str结尾。
  public String replace(char old,char new)：将就字符串替换为新字符串。
  串名.split(String str)： 根据正则表达式str做拆分，返回的是地址值，应使用Arrays.toString()来进行输出。
  public int compareTo(String str)：比较大小。
• 可变字符串
  StringBuffer：JDK1.0提供，运行效率慢，线程安全。
  StringBuilder：JDK5.0提供，运行效率快，线程不安全。
• BigDecimal类
  -注意最好不要使用double作为构造函数的参数，不然依然会有不精确的方法，有坑！！
  -最好使用String型数据作为构造函数的参数；double转String，直接拼一个空串即可
  位于java.math包中，用于精确计算浮点数，创建方式：
  BigDecimal bd = new BigDecimal(1.0);
  减法：subtract；加法：add；乘法：multiply；除法：divide。

 private static void m2(double a, double b) {
        BigDecimal bd1 = new BigDecimal(a+"");
        BigDecimal bd2 = new BigDecimal(b+"");

        System.out.println("加法运算："+(bd1.add(bd2)));
        System.out.println("减法运算："+(bd1.subtract(bd2)));
        System.out.println("乘法运算："+(bd1.multiply(bd2)));
        System.out.println("除法运算："+(bd1.divide(bd2)));
    }

• Date类
  表示特定的瞬间，精确到毫秒，Date类中大部分方法都已经被Calender类所替代。1s=1000ms=1000us=1000ns.

package outin;

import java.util.Date;

public class test {
	public static void main(String[] args) {
		//创建日期类
		Date date1 = new Date();
		//输出当前日期时间
		System.out.println(date1.toString());
		// 昨天的时间
		Date date2 = new Date(date1.getTime() - (60 * 60 * 24 * 1000));
		System.out.println(date2.toLocaleString());
		// 判断今天是否在昨天之后
		System.out.println(date1.after(date2));
		//今天比昨天多了多少天
		System.out.println(date1.compareTo(date2));
		//比较是否相等
		System.out.println(date1.equals(date2));
	}
}

• Calendar类
  提供了获取或设置各类日期字段的方法。
  构造方法：protected Calenda() ，由于修饰符是protected，所以无法直接创建该对象。
  
  应用：

package outin;

import java.util.Calendar;

public class test {
	public static void main(String[] args) {
		Calendar cc = Calendar.getInstance();
		//输出日期时间
		System.out.println(cc.getTime().toLocaleString());
		//获取年月日
		int y=cc.get(Calendar.YEAR);
		int m=cc.get(Calendar.MONTH);
		int d=cc.get(Calendar.DAY_OF_MONTH);
		//获取时分秒
		int h=cc.get(Calendar.HOUR_OF_DAY);
		int min=cc.get(Calendar.MINUTE);
		int sec=cc.get(Calendar.SECOND);
		//修改时间(日改为5)
		Calendar cc1 = Calendar.getInstance();
		cc1.set(Calendar.DAY_OF_MONTH, 5);
		//小时减一
		cc1.add(Calendar.HOUR, -1);
		//获取一个月最多有多少天
		System.out.println(cc1.getActualMaximum(Calendar.DAY_OF_MONTH));
	}
}

• SimpleDateFormat类
  SimpleDateFormat是一个以与语言环境有关的方式来格式化或解析日期的工具类。格式化（日期->文本），解析反之。
  

package outin;

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

public class test {
	public static void main(String[] args) {
		SimpleDateFormat sdf1 = new SimpleDateFormat("yyyy年MM月dd日 HH:MM:ss");
		Date d = new Date();
		System.out.println(sdf1.format(d));
		//解析
		Date d2 = sdf1.parse("2000年10月22日");
	}
}

• System类
  System系统类，主要用于获取系统的属性数据和其他操作，构造方法为私有。
  System.arraycopy(源数组，复制位置，目标数组，目标数组位置，复制长度);