常用类

一.内部类

内部类的意义：就是不破坏外部类的封装性的同时，访问内部类的private权限。

1.成员内部类

• 可以操作外部类的私有属性

• 创建内部类对象时必须依赖外部类对象。

• 他的级别和外部类的方法和属性是一个级别

• 当外部类和成员内部类有相同属性，会优先访问内部类。

• 成员内部类不能定义静态成员，但可以包含静态常量（private static final ）
  

内部类编译会生成独立的字节码文件。如Test.class(外部类)，Test&dome.class(内部类）

//创建成员内部类对象
外部类 A对象 = new 外部类();
内部类 inner对象 = A对象.new 内部类()
inner.in();//内部类方法 

//一句话写法
内部类 inner = new 外部类().new 内部类(); 

2.静态内部类

• 静态内部类的级别和外部类一样

• 静态内部类内可以有静态成员

• 静态内部类要访问外部类的属性需要创建外部类对象

• 只有内部类才可以加静态修饰符
  
  静态内部类可以不用先创建外部类对象

 //静态内部类的创建
    外部类.内部类 inter=new 外部类.内部类();
    外部类.内部类.方法();

3.局部内部类

• 定义在外部类的方法中

• 作用范围只在方法中可以用

• 方法中的属性和局部内部类不能加访问权限修饰符

• 局部内部类里可以直接访问外部类属性。和方法一样

public class Student{
    //属性
    private name ="外部类的属性";
    //方法
    public void show(){
        final String Myname='局部变量'
        
        //局部内部类
        class Inter{
            //局部内部类的属性
            private String name="局部内部类的属性";
           
            public void show2(){
            	  int name = "局部内部类的方法中局部变量";
            	  //访问外部类的属性
                  System.out.println(Sudent.this.name);
                  System.out.println(new Student().name);
                  //访问局部内部类的属性
                  System.out.println(this.name);
                  //访问局部内部类的方法中的局部变量
                  System.out.println(name);
                    
            //访问方法局部变量 jdk1.7必须是常量，jdk1.8自动添加final
            //加final可以访问局部变量，但必须要和局部内部类的属性和方法中的变量名不同。
            //要修改final修饰的局部变量，要转换为单数组.
                  /*
1.为什么局部内部类和匿名内部类只能访问final修饰的局部变量？（可能是因为生命周期）
2.为什么在局部内部类中无法访问同名局部变量，但外部类中可以通过类名.this.属性的方式访问？
3.为什么加上数组就可以进行修改了？													
				  */
                  System.out.println(Myname);
            }
        }
        //创建局部内部类对象来调用方法show2
        new Inter().show2()
    }
    
}


//使用
public static void mian(String[] args){
    //创建外部类对象
    Student student = new Student();
    //通过show方法来使用局部内部类
    student.show()
} 

4.匿名内部类

• 没有类名的局部内部类

• 和局部内部类基本相同

• 匿名内部类其实有名字是编译器帮我们自动生成的，可以在编译好的class文件中找到他。

• 继承一个父类或实现一个接口

public class Outer{
public static void main(String[] args){
	 Userservice u = new Userservice(){
       public void Hello(){
         //使用匿名类进行方法重写
       }
   };
	u.Hello()
}
   new Innter().add();//匿名对象  
}
class Innter{ //一个java文件只能有一个public class
   public void add(){
       System.out.println("Test");
   }
} 
interface Userservice{
    void Hello();
} 

二.Object类

Object类是所有类的超集，所有的类都直接或间接的继承Object

• 作为参数，可以接收任何对象。
• 作为返回值，可以返回任何对象。
• 作为类型，可以存储任何对象。

Object中的方法

clone()//创建一个对象的副本
notify()
notifyAll()
wait()//
getClass()//返回一个类的运行时类。
hashCode()//返回对象的哈希值
toString()//返回包名和 @ 16位哈希值 。//建议所有子类重写此方法
equals()//比较的是地址
//重写equals方法
public bollean equals(Object obj){
    //1.判断两个对象是否是同一个引用
    if(this==obj){
        return true;
    }
    //2.判断是否为空
    if(obj==Null){
        return false;
    }
    //3.判断是否是同一个类型
    if(obj instanceof Student){
        Student s=(Student)obj;
        
        //4.比较属性
          if(this.name.equals(s.getName())&&this.age==s.getAge()){
              return true;
          }
    }
    return false;
} 
finalize()//当对象被判定为垃圾对象,jvm去调用的 手动回收垃圾，System.gc();
new Sudent('a',23);//标记 垃圾对象

三.包装类

包装器类是引用类型
Object可统一所有数据，包装器类的默认值是NULL。

8种包装类

1. Byte

2. Short

3. Integer

4. Long

5. Float

6. Double

7. Boolean

8. Character

包装类和基本类型转换

Number提高6种共性方法

1.装箱和拆箱&自动装箱和拆箱

//装箱 :将基本类型转换成引用类型
Integer integer = new Integer(23);
Integer integer = Integer.valueOf(234);
//拆箱
int int1 = Integer.intValue();

//JDK1.5后 可以使用自动装箱和拆箱
int int2 = 234;
Integer integer = int2;
int int2 = integer;
/*
		在查看class文件后可以看出其实也使用了valueOf
*/

2.基本类型和字符串之间的转换

//使用字符串拼接
int n1 = 100;
String s1 = n1+"";
//使用Integer的toString方法
String s2 = Integer.toString(n1);
//toString(n1,16);//16进制

//使用boolean true和非true
String s1 = "true";
boolean b1 = Boolean.parseBoolean(s1);
System.out.println(b1);

3.整数缓冲区

Integer integer1 = new Integer(100);
Integer integer2 = new Integer(100);
System.out.println(integer1 == integer2);
//结果为:false 因为引入类型存储在堆中。
Integer integer3 = 100;
Integer integer4 = 100;
System.out.println(integer3 == integer4);
//结果:true
Integer integer5 = 129;//通过查看valueOf源码的办法
Integer integer6 = 129;
System.out.println(integer5 == integer6);
//结果:false Integer在堆中的数组缓冲区大小-128 ~ 127如果有就使用缓冲区中的。 

四.String类

• 字符串是常量，不可改变性。
• 字符串字面值在字符串池中，可以共享（地址指向相同的值)。

//在栈中会有一个name指向方法区中的字符串常量池中test值，在赋值时会在常量池中找如果有就会直接用
String name = "test";
//张三赋值给name时，并没有修改数据，只是在常量池中重写开辟了一个张三的值，然后name指向它。
name = "张三";

创建字符串时有两种方式

//1.字面值
String name = "test";
//2.创建对象
String name = new String("test");
//创建对象的方式会在堆中创建一个对象，这个对象指向的是常量池中的值。而name是一个指向是一个地址。

String std1 = new String("test");
String std2 = new String("test");
System.out.println(std1 == std2);
//结果为false
//String中的equals方法重写了
System.out.println(std1.equals(std2));
//结果为true // 比的是地址

字符串常用的方法

int length()//返回字符的长度
char charAt()//通过下标获取字符
boolean contains(String stu)//判断当前字符串中是否包含stu
char[] toCharArray() //将字符串转换成字符数组
int indexOf();//返回字符首次出现的位置
int lastIndexOf();//返回字符最后出现的位置
String toUpperCase();//将小写转换为大写
String toLowerCase();//将大写转为小写
String trim();//字符去调前后的空格
boolean endWith()//判断字符串以什么结尾
String replace()//替换 把旧字符串替换成新字符串
String split(String stu);//根据stu做拆分

//字符串的equals方法可以比较字符大小写
String name = "zhang";
String name1 = "ZHANG";
System.out.println(name.equals(name1));
//忽略大小写
System.out.println(name.equalsIgnoreCase(name1));

//compareTo
String name = "abc";
String name1 = "xyz";
System.out.println(name.compareTo(name1));
//比较name的第一个字符的ascll码表中的数字减去name1中的第一个字符的数字，返回一个int

String name = "abc";
String name1 = "abcxyz";
//如出现上述情况就会比较字符串的长度

可变字符串

• StringBuffer：可变长字符串，JDK1.0提供，运行效率慢，线程安全。
• StringBuilder：可变长字符串，JDK5.0，运行效率快，线程不安全。

StringBuffer stringBuffer = new StringBuffer();
//1.append 追加
stringBuffer.append("java");
System.out.println(stringBuffer.toString);
//2.insert 选择位置添加
stringBuffer.insert(0,'学习');
//3.replace 替换
stringBuffer.replace(0,4,"hello");
//4.delete 删除

/**
 * StringBuffer和StringBuilder和执行效率
 *
 */

public class String03 {
    public static void main(String[] args) {
        //开始时间
        long start = System.currentTimeMillis();

//        String s1="";
//        for (int i = 0; i <99999 ; i++) {
//            s1+=i;
//        }


        StringBuffer s2=new StringBuffer();
        for (int i = 0; i < 99999; i++) {
            s2.append(i);
        }

//        StringBuilder s3=new StringBuilder();
//        for (int i = 0; i < 99999; i++) {
//            s3.append(i);
//        }
//
        long end = System.currentTimeMillis();
        System.out.println("用时:"+(end-start));
    }
}

经测试StringBuffer和StringBuilder差别不是很大(可能是运算量不够大导致的）但都比String字符串快，而且结果非常明显。

五.Math工具类

BigDecimal的使用

double d1=1.0;
double d2=0.9;
System.out.println(d1-d2);
double s1 = (1.4-0.5)/0.9;
//结果为：0.09999999999999998
//在特殊场和中不允许有误查，如金融方面所有需要使用BigDecimal
//BigDecimal用法
BigDecimal bd1=new BigDecimal("1.0"); 
BigDecimal bd2=new BigDecimal("0.9");

//减发
BigDecimal s1=bd1.subtract(bd2);//结果：0.1 

//加法
BigDecimal s2=bd1.add(bd2);

//乘法
BigDecimal s3=bd1.multiply(bd2);

//除法
BigDecimal s4=bd1.divide(bd2);

BigDecimal s5= new BigDecimal("1.4").subtract(new BigDecimal("1.0")); 

六.System类

方法名	说名
static void arraycopy()	复制数组
static long currentTimeMillis()	获取系统时间返回毫秒数
static void gc()	建议JVM启动垃圾回收器
static void exit(int status)	退出JVM 是0正常退出，非0是异常退出

System.arraycopy(源数组，从那个位置，目标数组，目标数组的位置，复制的长度);

native 本地方法 没有方法体是用C/C++实现的

Arrays.copyOf()的源代码是用的arraycopy 

七.时间日期类

Date类中的大部分方法都已经被Calendar类中的方法所取代

时间单位

• 1秒 = 1000毫秒
• 1毫秒 = 1000微秒
• 1微秒 = 1000纳秒

Calendar类

Calendar类无法通过构造方法来创建对象。修饰成受保护的，要创建对象需要调用静态方法
static Calendar getInstance()

SimpleDateFormat类是一个语言环境有关来格式化和解析日期具体类。

字符串→日期解析 日期→字符串