目录

一、内部类

 1.成员内部类

2.静态内部类

3.局部内部类

4.匿名内部类

二、Object类

1.getclass方法

2.hashCode()方法

3.toString（）方法

4.equals()方法

5.finalize()方法

三、包装类

1、类型转换与装箱、拆箱

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

3.整数缓冲区

四、String类

1.常用方法

2、StringBuffer和StringBuilder的区别

五、BigDecimal的使用

六、Date类

七、Calender类

九、System类

一、内部类

        分类：成员内部类、静态内部类、匿名内部类、局部内部类

        内部类：在一个类的内部定义一个完整的类 

public class body {//身体
	private String name;
	public class head{	//头部  //
		public void show() {
			System.out.println(name);
		}
	}
}

特点：*内部类编译后会生成一个单独的字节码文件*

*内部类可以直接访问外部类的私有成员，而不破坏封装*

java中所有类都继承object吗 java所有的类_字符串

 1.成员内部类

        概述：在类的内部定义，与实例变量、实例方法同级别的类。

                   外部类的一个实例部分，创建内部类对象时，必须依赖外部类对象。

public class Outer {
	private String name="胡7";
	private int age=20;
	
	class Inner{
		private String address="北京";
		private String phone="110";
		private String name="胡6";
		
		public void show() {
			//打印外部类的属性
			System.out.println(Outer.this.name);
			System.out.println(name);
			System.out.println(age);
			System.out.println(address);
			System.out.println(phone);
		}
	}
	
}


import com.hu.javaLearning.commonClasses.innerClass.Outer.Inner;

public class Test {

	public static void main(String[] args) {
		Inner inner=new Outer().new Inner();
		inner.show();
	}

}

成员内部类不可以包含静态成员，但是可以包含静态常量。

//不可以包含静态成员
private static String country="中国";

//可以包含静态常量
private static final String country="中国";

2.静态内部类

        静态内部类和外部类相同

public class Outer {
	private String name="xxx";
	private int age=18;
	
	static class Inner{
		//静态内部类和外部类相同
		private String address="北京";
		private String phone="111";
		//静态成员
		private static int count=1000;
		
		public void show() {
			//调用外部为的属性
			Outer outer=new Outer();
			System.out.println(outer.name);
			System.out.println(outer.age);
			//待用静态内部类的属性和方法
			System.out.println(address);
			System.out.println(phone);
			//调用静态内部类的静态属性
			System.out.println(Inner.count);
			
		}
	}
}

静态类只能是内部类，普通的类不能是静态类

3.局部内部类

        注意考虑局部变量是否为常量问题

package com.hu.javaLearning.commonClasses.partClass;

public class Outer {
	private String name="胡某";
	private int age=35;
	public void show() {
		//局部变量
		/*final*/String address="深圳";
		
		//局部内部类:注意不能加任何访问修饰符
		class Inner{
			private String phone="18325387777";
			private String email="2237352600@qq.com";
			
			public void show2() {
				//访问外部类的属性
				//Outer.this.是默认的
				System.out.println(Outer.this.name);
				//访问局部变量，jdk1.7要求，变量必须是常量final，jdk1.8自动添加final
				System.out.println(address);
				System.out.println(age);
				System.out.println(phone);
				System.out.println(email);
			}
		}
		//想要访问局部内部类必须创建对象
		Inner inner=new Inner();
		inner.show2();
	}
}

定义在外部类方法中，作用范围和创建对象范围仅限于当前方法。

局部内部类访问外部类当前方法中的局部变量时，因无法保障变量的声明周期与自身相同，变量必须修饰为final。

限制类的适用范围。

4.匿名内部类

没有类名的局部内部类（一切特征都与局部内部类相同）。

必须继承一个父类或者实现一个接口。

//         匿名内部类也会创建class文件

定义类，实现类，创建对象的语法合并，只能创建一个该类的对象。

优点：减少代码量

缺点：可读性差

public class TestUsb {
	public static void main(String[] args) {
		//创建接口类型的变量
//		USB usb=new mouse();
//		usb.service();
		
		//局部内部类
/*		class Fan implements USB{

			@Override
			public void service() {
				// TODO 自动生成的方法存根
				System.out.println("连接电脑成功，风扇开始工作。。");
			}
			
		}   
		//使用局部内部类创建对象，缺点是只创建了一次，代码量增多
		 USB usb=new Fan();
		 usb.service();
		 */
		
		
		//使用匿名内部类优化（相当于创建了一个局部内部类）
		 USB usb=new USB(){
			 @Override
				public void service() {
					// TODO 自动生成的方法存根
					System.out.println("连接电脑成功，风扇开始工作。。");
				}
		 };
		 usb.service();
	}
}

二、Object类

        超类、基类，所有类的直接或者间接父类，位于继承树的最顶端。

        任何类，如没有书写extends显示继承某个类，都默认直接继承Object类，否则为间接继承。

        Object类中所定义的方法，是所有对象所具备的方法。

        Object类型可以储存任何对象。

                作为参数，可接受任何对象。

                作为返回值，可返回任何对象。

1.getclass方法

        返回引用中存储的实际对象类型。

        应用：通常用于判断两个引用中实际存储对象类型是否一致。

public class TestStudent {
	
	public static void main(String[] args) {
		// TODO 自动生成的方法存根
		TestStudent t=new TestStudent();
		Class class1=t.getClass();
		System.out.println(class1);
	}

}

2.hashCode()方法

        返回该对象的哈希码值

        哈希值根据对象的地址或字符串或数字使用hash算法计算出来的int类型的数值。

        一般情况下相同对象返回相同哈希码。

3.toString（）方法

        返回该对象的字符串表示（表现形式）。

        可以根据 程序需求覆盖该方法，如：展示对象各个属性值。

4.equals()方法

        默认实现为（this == obj），比较两个对象地址是否相同

        可进行覆盖，比较两个对象的内容是否相同。

5.finalize()方法

        当对象被判定为垃圾对象时，由JVM自动调用此方法，用以标记立即对象，进入回收队列。

        垃圾对象：没有有效引用指向此对象时，为垃圾对象。

        垃圾回收：有GC销毁垃圾对象，释放数据存储空间。

        自动回收机制：JVM的内存耗尽，一次性回收所有垃圾对象。

        手动回收机制：使用System.gc()：通知JVM执行垃圾回收。

三、包装类

        定义：基本类型类型所对应的引用数据类型。

        Object可统一所有数据，包装类的默认值是null。

                基本数据类型

                        包装类型

byte

Byte

short   

Short

int

Interger

long

Long

float

Float

double

Double

boolean

Boolean

char

Character

1、类型转换与装箱、拆箱

        装箱：把栈里的数据放进堆里面

        拆箱：把堆里的数据放进栈里面

*jdk1.5之前使用的方式装箱拆箱
public class Demo1 {

	public static void main(String[] args) {
		//类型转换：装箱操作，基本类型转成引用类型的过程
		//基本类型
		int num1=18;
		//使用Integer类创建对象    装箱操作
		Integer integer1=new Integer(num1);
		//System.out.println(integer1.getClass());
		Integer integer2=Integer.valueOf(num1);
		//类型转换:拆箱，引用类型转成基本类型
		Integer integer3=new Integer(100);
		int num2=integer3.intValue();
	}

}

jdk1.5以后实现自动装箱，拆箱

int age=30;
//自动装箱
Integer integer4=age;
//自动拆箱
int age2=integer4;

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

//基本类型和字符串之间转换
		//一、基本类型转换为字符串
		int n1=100;
		//1.使用+号
		String s1=n1+"1";
		//2.使用toString()方法
		String s2=Integer.toString(n1);
		String s3=Integer.toString(n1,16);//变成16进制转换成字符串返回;
		String s4=Integer.toString(n1,8);
		System.out.println(s1);
		System.out.println(s2);
		System.out.println(s3);
		System.out.println(s4);
		//二、字符串转换成基本类型
		String str="150";
		//使用Integer.parseXXX();
		Integer.parseInt(str);
		System.out.println(str);

  //        boolean字符串形式转化成基本类型“true”--->true   非“true”--->false

String s1="true";
Boolean b1=Boolean.parseBoolean(s1);
String s2="tru";
Boolean b2=Boolean.parseBoolean(s2);
System.out.println(b1);
System.out.println(b2);

3.整数缓冲区

        

//整数缓冲区
public class Demo1 {

	public static void main(String[] args) {
		Integer integer1=new Integer(100);
		Integer integer2=new Integer(100);
		System.out.println(integer1==integer2);
		
		Integer integer3=100;//自动装箱
		Integer integer4=100;
		System.out.println(integer3==integer4);
		 //输出为true
		Integer integer5=200;//自动装箱
		Integer integer6=200;
		System.out.println(integer5==integer6);
         //输出false	
}
}

java中所有类都继承object吗 java所有的类_System_02

在缓存区中存储的范围是-128~127， 其中low=-128,high=127;当整数为这个范围内时，不需要重新创建对象，而不在这个范围内需要创建对象。

四、String类

字符串是常量，创建之后不可改变。

字符串字面值存储在字符串池中，也可以共享。（对象在栈中存储，字符串的值存储在方法池中，指向同一个字符串）

String s="hello";产生一个对象，字符串池中存储。

String s=new String("hello");

public class Demo {

	public static void main(String[] args) {
		//第一种方式创建字符串
		String name="hello";   
		name="zhangsan";
		String name2="zhangsan";
		System.out.println(name==name2);
		/*true*/
		
		//演示字符串的另一种创建方式
		String str=new String("java是最好的语言");
		String str2=new String("java是最好的语言");
		System.out.println(str==str2);
        /*false*/
		
	}

}

1.常用方法

1）、length()：返回长度

2）、charAt(int index):返回某个位置的字符

3）、contains(String str):判断是否存在某个字符串

4）、toCharArray(）：将字符串转化成数组。

String str=new String("java是最好的语言");
		//4.toCharArray():
		System.out.print(Arrays.toString(str.toCharArray()));

java中所有类都继承object吗 java所有的类_字符串_03

5）、indexOf(String str):查找str首次出现的下标，存在，则返回该下标；不存在，则返会-1；

6）、lastIndexOf(String str):查找最后出现的下标

String str=new String("java是最好的语言，哎呦喂，java倍棒");
System.out.println(str.indexOf("java"));
System.out.println(str.indexOf("java",3));
//第二个参数表示，在x下标后出现某字符串的首次位置
System.out.println(str.lastIndexOf("java"));

7）、trim（）:去掉字符串前后的空格

8）、toUpperCase（）：将小写转成大写。

9）、endWith（String str）：判断字符串是否以str结尾

String str=new String("     java是最好的语言，哎呦喂，JAVA倍棒");
System.out.println(str);
System.out.println(str.trim());
System.out.println(str.toUpperCase());
System.out.println(str.toLowerCase());
String filename="hello.java";
System.out.println(filename.endsWith(".java"));

10）、replace（char old,char new）：用新的字符或者字符串替换旧的字符或者字符串

String str=new String("java是最好的语言，哎呦喂，java倍棒");
		System.out.println(str.replace("java", "php"));

java中所有类都继承object吗 java所有的类_字符串_04

11）、spilt（）：对字符串进行拆分

String say=" java is the best     programing language,   java xiang";
		String[] arr=say.split("[ ,]+");
//[ ,]表示用空格或者逗号分隔开；
//“+”代表可以多个使用符号进行分割；
		System.out.println(arr.length);
		for (String string:arr) {
		System.out.println(string);

12）、equals（）方法

String s1="hello";
		String s2="Hello";
		System.out.println(s1.equals(s2));
		//忽略大小写的比较
		System.out.println(s1.equalsIgnoreCase(s2));

13）、compareTo（）：比较大小

String s3="abc";
		String s4="xyz";
        String s5="abcde"
		System.out.println(s3.compareTo(s4));

        当两个字符串是包含关系，则比较的是长度关系，返回的是长度差值。        

        当两个字符串不是包含关系，比较第一个不同字符的字典位置差值。

2、StringBuffer和StringBuilder的区别

StringBuffer:可变长字符串，JDK1.0提供，运行效率慢、线程安全。

StringBuilder:可变长字符串，JDK5.0提供，运行效率快、线程不安全。

二者都比字符串效率高并且更节省空间。

StringBuffer的几种操作：

public static void main(String[] args) {
		StringBuffer sb=new StringBuffer();
		//1.append();追加
		sb.append("java世界第一");
		System.out.println(sb.toString());
		sb.append("java牛逼");
		System.out.println(sb.toString());
		//2.insert();添加
		sb.insert(0,"哇哦！");
		System.out.println(sb.toString());
		//3.replace();替换
		sb.replace(0,1,"enen");
		System.out.println(sb.toString());
		//4.delete();删除
		sb.delete(0,3);
		System.out.println(sb.toString());
		
	}

（StringBuilder相同，但是多用于单线程）

速度比较：

package com.hu.javaLearning.commonClasses.StringClass;
/**
 * 验证StringBuilder效率高于String
 * @author 22373
 *
 */
public class Test {

	public static void main(String[] args) {
		long start=System.currentTimeMillis();
		String string="";
		for(int i=0;i<99999;i++) {
			string+=i;
		}
		System.out.println(string);
		long end=System.currentTimeMillis();
		System.out.println("String用时："+(end-start));
		
		long start2=System.currentTimeMillis();
		StringBuilder sb=new StringBuilder();
		for(int i=0;i<99999;i++) {
			sb.append(i);
		}
		System.out.println(sb.toString());
		long end2=System.currentTimeMillis();
		System.out.println("StringBuilder用时："+(end2-start2));
	}
}

五、BigDecimal的使用

精确存储

double近似存储

double d1=1.0;
		double d2=0.9;
		System.out.println(d1-d2);
		//结果：0.09999999999999998
		
		//面试题
		double result=(1.4-0.5)/0.9;
		System.out.println(result);
		//结果：0.9999999999999999

BigDecimal的加减乘除

import java.math.BigDecimal;

public class BigDecimal_Demo {

	public static void main(String[] args) {
		// TODO 自动生成的方法存根
		double d1=1.0;
		double d2=0.9;
		System.out.println(d1-d2);
		//结果：0.09999999999999998
		
		//面试题
//		double result=(1.4-0.5)/0.9;
//		System.out.println(result);
		//结果：0.9999999999999999
		
		
		//BigDecimal,大的浮点数精确计算
		BigDecimal bd1=new BigDecimal("1.0");
		BigDecimal bd2=new BigDecimal("0.9");
		
		//减法
		BigDecimal result1=bd1.subtract(bd2);
		System.out.println(result1);
		
		//加法
		BigDecimal result2=bd1.add(bd2);
		System.out.println(result2);
		
		//乘法
		BigDecimal result3=bd2.multiply(bd1);
		System.out.println(result3);
		
		//除法
		BigDecimal result4=bd1.divide(bd2,2,BigDecimal.ROUND_HALF_UP);
		//保留两位小数并且向上四舍五入
		System.out.println(result4);
	}
}

使用BigDecimal除法除不尽时，需要抛出异常或者使用重载方法（保留几位小数，进位方式）

六、Date类

Date表示特定的瞬间，精确到毫秒。Date类中的大部分方法已经被Calender类中的方法所取代。

Unix元年：1970年1月1日，00：00：00 GMT）

//1、创建Date对象
		Date d=new Date();
		System.out.println(d.toString());
		//按照当地习惯输出时间（已经过时了）
		System.out.println(d.toLocaleString());
		//距离元年时间的毫秒数
		System.out.println(d.getTime());
		//昨天
		Date d2=new Date(d.getTime()-60*60*24*1000);
		System.out.println(d2.toLocaleString());
		//2、方法after、before
		boolean b1=d.after(d2);
		System.out.println(b1);
		boolean b2=d.before(d2);
		System.out.println(b2);
		//3、compareTo()方法
		System.out.println(d.compareTo(d2));
		//4、equals()方法
		boolean b3=d.equals(d2);
		System.out.println(b3);

七、Calender类

Calendar提供了获取或者设置各种日历字段的方法。

构造方法：

        protected Calendar( )：由于修饰符是protected，所以无法直接创建该对象。

//创建Calender对象
		Calendar c=Calendar.getInstance();
		System.out.println(c.getTime().toLocaleString());
		//打印距离元年时间的毫秒差值
		System.out.println(c.getTimeInMillis());
		//获取时间信息
		//获取年
		int year=c.get(Calendar.YEAR);
		System.out.println(year);
		//月 :特殊，从0开始，0~11
		int month=c.get(Calendar.MONTH);
		System.out.println(month);
		//日
		int day=c.get(Calendar.DAY_OF_MONTH);
		System.out.println(day);
		//小时
		int hour=c.get(Calendar.HOUR_OF_DAY);
		System.out.println(hour);
		//分
		int minute=c.get(Calendar.MINUTE);
		System.out.println(minute);
		//秒
		int second=c.get(Calendar.SECOND);
		System.out.println(second);
		System.out.println(day);
		System.out.println(year+"年"+(month+1)+"月"+day+"日"+hour+"时"+minute+"分"+second+"秒");

修改时间，并且通过set方法可以改变时间

//修改时间
		Calendar c2=c.getInstance();
		//对象Calendar 可以通过set方法改变时间
		c2.set(Calendar.DAY_OF_MONTH,5); 
		System.out.println(c2.getTime().toLocaleString());

修改时间的另一种方式：add( )方法

//add()方法
		c2.add(Calendar.HOUR,1);
		System.out.println(c2.getTime().toLocaleString());
		c2.add(Calendar.HOUR,-2);
		System.out.println(c2.getTime().toLocaleString());

补充方法：getActualMaximum( )、getActualMinimum( )方法

int max=c2.getActualMaximum(Calendar.DAY_OF_MONTH);
		int min=c2.getActualMinimum(Calendar.DAY_OF_MONTH);
		System.out.println(max);
		System.out.println(min);

八、SimpleDateFormat类

SimpleDateFormat是一个以与环境有关的方式来格式化和解析日期的具体类。

进行格式化（日期 -> 文本）、解析（文本 - >日期）。

常用的时间模式字母

字母

日期或时间

实例

y

年

2019

M

年中月份

08

d

月中天数

10

H

1天中小时数(0~23)

22

m

分钟

16

s

秒

59

S

毫秒

367

public static void main(String[] args) throws Exception{
		// TODO 自动生成的方法存根
		//1、创建SimpleDateFormat对象 
		SimpleDateFormat sdf2=new SimpleDateFormat("yyyy年MM月dd HH:mm:ss:SS");
		SimpleDateFormat sdf=new SimpleDateFormat("yyyy/MM/dd");
		//2、创建Date
		Date date=new Date();
		//格式化date(把日期转成字符串)
		String s=sdf2.format(date);
		System.out.println(s);
		//解析（把字符串转成日期）
		Date date2=sdf.parse("1990/05/01"); 
		//parse里的字符串如果和SimpleDateFormat对象创建的格式不同，则会导致出现异常，需要抛出
		System.out.println(date2);
	}

九、System类

System系统类，主要用于实现获取系统的属性数据和其他操作 ，构造方法私有的，不用创建对象。

方法名字

说明

static void arraycopy(...)

复制数组

static long currentTimeMills();

获取当前系统时间，返回的是毫秒值

static void gc();

建议JVM赶快启动垃圾回收器回收垃圾

static void exit(int status)；

退出jvm,如果参数是0表示正常退出jvm，非0表示异常退出jvm。

public class Demo {

	public static void main(String[] args) {
		// TODO 自动生成的方法存根
//		1、arraycopy():数组的复制
//		src:源数组
//		srcPos:从哪个位置开始复制
//		dest:目标数组
//		destPos:目标数组的位置
//		length:需要复制地长度
		int[] arr= {20,18,15,8,3,46,45,90};
		int[] dest=new int[8];
		System.arraycopy(arr, 1, dest, 4, 4);
		for(int i=0;i<dest.length;i++) {
			System.out.println(dest[i]);
		}
		//Arrays.copyOf() 是引用的System.arraycopy()方法的
		
		//currentTimeMills()方法  //返回当前毫秒数 可以用来计时
		System.out.println(System.currentTimeMillis());
		long start=System.currentTimeMillis();
		{
			//随意代码段
		}
		long end=System.currentTimeMillis();
		System.out.println("用时："+(end-start));
		
		
		//3、System.gc()
	}
}