常用类之内部类，Object类，包装类，String类和可变长字符串

常用类

一.内部类

包括：成员内部类，静态内部类，局部内部类，匿名内部类

概念：一个类中定义一个完整的类。

特点：

• 编译之后可生成独立的字节码文件
• 内部类可直接访问外部类的私有成员
• 可为外部类提供必要的功能

成员内部类

• 在类的内部定义，与实例变量、实例方法同级别的类。
• 外部类的一个实例部分，创建内部类对象时，必须依赖外部类对象。
• Outer out = new Outer();
• Outer.Inner in = out.new Inner();
• 当外部类、内部类存在重名属性时，会优先访问内部类属性。
• 内部类中不能存在静态属性，静态属性需要在类加载的时候就初始化，不然会出现冲突。

案例：

public class Outside {
	private String name="张三";
	private int age =15;

	//成员内部类
//	1.弥补Java单继承的缺陷，实现另类的多继承
//	2.为了更好的封装
	class Inside extends A{
		private String phone="123456";
		private String name="李四";
	
		//类加载加载了静态的属性，出现冲突，内部类的属性需要在外部类实例化后才能进行实例化，但是静态属性在
//		类加载的时候就需要初始化，比外部类实例化的顺序要早，出现冲突
//		private static String email="123";
		public void show() {
			//使用内部类的属性
			System.out.println(phone);
			//使用外部类的属性
			System.out.println(name);
			System.out.println(age);
			//打印外部类的属性，内部类属性和外部类的属性名字相同Outer.this.()
			System.out.println(Outside.this.name);
		}
	}
	class Inside2 extends B{
		
	}
	class Inside3 extends C{
		
	}
	
	public void info() {
		Inside i1=new Inside();
		Inside2 i2=new Inside2();
		Inside3 i3=new Inside3();
		i1.a();
		i2.b();
		i3.c();
		
	}	
}

public class A {
	public void a() {
		System.out.println("a");
	}
}

public class B {
	public void b() {
		System.out.println("b");
	}
}

public class C {
	public void c() {
		System.out.println("c");
	}
}

public class Test {

	public static void main(String[] args) {		
		//成员内部类调用方法
		Outside o=new Outside();
		Outside.Inside i=o.new Inside();
		i.show();	
		System.out.println("==============");
		Outside.Inside i1=new Outside().new Inside();				
		i1.show();

	}

}

静态内部类

• 不依赖外部类对象，可直接创建或通过类名访问，可声明静态成员。
• 只能直接访问外部类的静态成员（实例成员需实例化外部类对象）。
• Outer.Inner inner = new Outer.Inner();
• Outer.Inner.show();

案例： 

public class Outside {
      
	private String name="张三";
	private int age =12;
	private static String sex="男";
	
	/**
	 * 静态内部类
	 * 1.只能直接访问外部类的静态成员（实例成员需实例化外部类对象）
	 * */
	
	static class Inside{
		private String address="深圳";
		private int count=120;
		private static String phone ="1234";
		
		public void show() {
			System.out.println(sex);
			System.out.println(address);
			System.out.println(count);
			System.out.println(phone);
			
			//静态内部类中使用外部类的属性或方法，需要实例化外部类，
			Outside o=new Outside();
			System.out.println(o.age);
			System.out.println(o.name);
		}
	}
	
}

public class Test {

	public static void main(String[] args) {
//		Outside o=new Outside();
		Outside.Inside in=new Outside.Inside();
		in.show();		
	}
}

局部内部类

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

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

• 限制类的使用范围。

案例：

public class Outside {

	private String name="张三";
	private int age =12;
	
	public void info() {
		System.out.println(name);
		
		String address="深圳";
		//定义局部变量jvm帮我们默认添加了final
	//	address="北京";
		//定义局部内部类
		//在方法内定义的类
		
		class Inside{
			private String phone ="123";
			public void show() {			
				System.out.println(phone);
				System.out.println(name);
				System.out.println(address);
			}
		}
		Inside ins=new Inside();
		ins.show();
	}
	public static void main(String[] args) {
		Outside out=new Outside();
		out.info();
	}
}

匿名内部类*

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

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

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

案例： 

public class Text {

	public static void main(String[] args) {
		//接口引用指向子类对象
		//父类引用指向子类
		Usb u=new Mouse();
		u.services();
		//局部内部类
		class InnerMouse implements Usb{

			@Override
			public void services() {
				System.out.println("局部内部类使用鼠标");
			}			
		}
		Usb u1=new InnerMouse();
		u1.services();
		
		//匿名内部类
		//不是实例化接口
		//实际上是一个没有名字（自动生成名字的）的局部内部类
		Usb usb=new Usb() {
			@Override
			public void services() {
				System.out.println("匿名内部类使用鼠标");
			}
		};
		usb.services();
	}
}

public class Mouse implements Usb{
	@Override
	public void services() {
		System.out.println("正常使用鼠标");
	}
}

public interface Usb {
	void services();
}

二.Object类*

1.概述

• 超类、基类，所有类的直接或间接父类，位于最顶层。
• 任何类，如果没有书写extends显示继承某个类，都默认直接继承Object类，否则为间接继承。
• Object类中所定义的方法，是所有对象都具备的方法。
• Object类型可以储存任何对象。
• 作为参数，可以接受任何对象。
• 作为返回值，可以返回任何对象。

2.常用方法

2.1getClass()

public final Class<?> getClass(){...}

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

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

2.2hashCode()

public int hashCode(){...}

• 返回该对象的十进制的哈希码值。

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

• 哈希码并不唯一，可保证相同对象返回相同哈希码，尽量保证不同对象返回不同哈希码。

2.3toString()

public String toString(){...}

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

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

综合案例：

public class Student  {
	private String name;
	private int age;
	public Student() {
		// TODO Auto-generated constructor stub
	}
	
	public Student(String name, int age) {
		super();
		this.name = name;
		this.age = age;
	}

	public String getName() {
		return name;
	}
	public void setName(String name) {
		this.name = name;
	}
	public int getAge() {
		return age;
	}
	public void setAge(int age) {
		this.age = age;
	}


	@Override
	public String toString() {
		return "Student [name=" + name + ", age=" + age + "]";
	}
		
	@Override
	public boolean equals(Object obj) {
		//1判断两个对象是否是同一个引用
		if(this==obj) {
			return true;
		}
		//2判断obj是否null
		if(obj==null) {
			return false;
		}
		//3判断是否是同一个类型
//		if(this.getClass()==obj.getClass()) {
//			
//		}
		//intanceof 判断对象是否是某种类型
		if(obj instanceof Student) {
			//4强制类型转换
			Student s=(Student)obj;
			//5比较熟悉
			if(this.name.equals(s.getName())&&this.age==s.getAge()) {
				return true;
			}
						
		}
		return false;
	}
	
	@Override
	protected void finalize() throws Throwable {
		System.out.println(this.name+"对象被回收了");
	}

}

public class TestStudent {
	public static void main(String[] args) {
		//1getClass方法
		System.out.println("------------1getClass---------");
		Student s1=new Student("aaa", 20);
		Student s2=new Student("bbb",22);
		//判断s1和s2是不是同一个类型
		Class class1=s1.getClass();
		Class class2=s2.getClass();
		if(class1==class2) {
			System.out.println("s1和s2属于同一个类型");   //true
		}else {
			System.out.println("s1和s2不属于同一个类型");
		}
		System.out.println("-----------2hashCode------------");
		//2hashCode方法
		System.out.println(s1.hashCode());
		
		System.out.println(s2.hashCode());
		Student s3=s1;
		System.out.println(s3.hashCode());     //s1和s3的hashCode相等
		
		//3toString方法
		System.out.println("-----------3toString------------");
		System.out.println(s1.toString());
		System.out.println(s2.toString());
		
		//4equals方法：判断两个对象是否相等
		System.out.println("-----------4equals------------");
		System.out.println(s1.equals(s2));
		
		Student s4=new Student("小明", 17);
		Student s5=new Student("小明",17);
		System.out.println(s4.equals(s5));     //重写了equals后为true
		
		
	}
}

2.4equals()

public boolean equals(Object obj){...}

• 默认实现为(this == obj)，比较两个对象地址是否相同。

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

equals重写步骤：

1.比较两个引用是否指向同一个对象。

2.判断obj是否为null。

3     (1)判断两个引用指向的实际对象类型是否一致。

       (2)强制类型转换。

       (3)依次比较各个属性值是否相同

案例：

	@Override
	public boolean equals(Object obj) {
		//1判断两个对象是否是同一个引用
		if(this==obj) {
			return true;
		}
		//2判断obj是否null
		if(obj==null) {
			return false;
		}
		//3判断是否是同一个类型
//		if(this.getClass()==obj.getClass()) {
//			
//		}
		//intanceof 判断对象是否是某种类型
		if(obj instanceof Student) {
			//4强制类型转换
			Student s=(Student)obj;
			//5比较熟悉
			if(this.name.equals(s.getName())&&this.age==s.getAge()) {
				return true;
			}		
		}
		return false;
	}

2.5finalize()

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

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

三.包装类

1.概述

基本数据类型所对应的引用数据类型。(包装类的默认值为null)

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

2.装箱、拆箱

 类型转换与装箱，拆箱（八种包装类之间的转换方式）

.parsexxx()静态方法 ，(除了Character)

.valueOf() 静态方法， 都有

案例：

public class Test3 {

	public static void main(String[] args) {
		String a = "15";
		System.out.println(Integer.valueOf(a));
		
		
		char c = 65;
		System.out.println(Character.valueOf(c));           //A
		// 包装类 各种转换
		Integer i = 10;

		System.out.println(i.toString() + 1);             //101
		System.out.println(i + "" + 1);					  //101
		System.out.println("================");
		// 包装类
		int i1 = 1;
		// 装箱 基础数据类型转为包装类 ==>装箱
		Integer int1 = Integer.valueOf(i1);
		// 拆箱 包装类转为基础数据类型==>,拆箱
		int i2 = int1.intValue();
		System.out.println("============自动装箱拆箱=============");

		int i3 = 1;
		//自动装箱
		Integer int2 = i3;
		//自动拆箱
		int i4 = int2;
		System.out.println(int2);             //1
		System.out.println(i4);               //1
	}

}

3.整数缓冲区

• Java预先创建了256个常用的整数包装类型对象。 -128~127

四.String类

1.概述

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

常用创建方式：

String s1="hello";

String s2=new String ("world");

2.常用方法

方法名	描述
public char charAt(int index)	根据下标获取字符
public boolean contains(String str)	判断当前字符串中是否包含str
public char[] toCharArray()	将字符串转换成数组。
public int indexOf(String str)	查找str首次出现的下标，存在，则返回该下标；不存在，则返回-1
public int length()	返回字符串的长度
public String trim(）	去掉字符串前后的空格
public String toUpperCase()	将小写转成大写
public boolean endsWith(String str)	判断字符串是否以str结尾
public String replace(char oldChar,char newChar)	将旧字符串替换成新字符串
public String[] split(String str)	根据str做拆分
public String subString(int beginIndex,int endIndex)	在字符串中截取出一个子字符串

代码：

import java.util.Arrays;

public class Text1 {
	public static void main(String[] args) {
		String word="1234561";
		//返回指定索引
		System.out.println(word.charAt(0));
		//字符串长度 方法length()
		System.out.println(word.length());
		//返回Boolean值，字符串中是否包含“ ”
		System.out.println(word.contains("12"));
		//字符串转为数组
		char [] arr=word.toCharArray();
		System.out.println(Arrays.toString(arr));
		//判断字符串中首次出现的下标
		System.out.println(word.indexOf("7"));
		System.out.println(word.lastIndexOf("6"));
		
		System.out.println("========================");
		//去除两边的空格
		String word2="  1Java    AbcD   2JAVA  ";
		System.out.println(word2);
		System.out.println(word2.trim());
		System.out.println("========================");
		//把字母转为大写
		System.out.println(word2.toUpperCase());
		//把字母转为小写
		System.out.println(word2.toLowerCase());
		System.out.println("========================");
		//判断是否以某一字符串开头或结尾
		System.out.println(word2.startsWith(" "));
		System.out.println(word2.endsWith(" "));
		System.out.println("========================");
		//替换
		String word3="java 牛哇！";
		System.out.println(word3.replace("java", "Java"));
		//拆分
		String [] str=word3.split("");
		System.out.println(Arrays.toString(str));
		String [] str2="哈六,哦几 乎都,是祭祀, 大 家".split("[ ,]+");
		System.out.println(Arrays.toString(str2));
		
		System.out.println("========================");
		String word4="java 牛啊啊！";
		//切割 从下标开始
		System.out.println(word4.substring(5));
		//左闭右开，左边保留，右边不留
		System.out.println(word4.substring(2, 9));
		System.out.println(word4.substring(0, word4.length()));
	
	}
}

五.可变字符串

概念：可在内存中创建可变的缓冲空间，存储频繁改变的字符串。

Java中提供两个可变字符串类：

StringBuilder：可变长字符串，运行效率快，线程不安全。（字符串长，运行快，不安全）

StringBuffer：可变长字符串，运行效率慢，线程安全。（字符串短，运行慢，安全）

方法名	属性
public StringBuilder append(String str)	追加内容。
public StringBuilder insert(int dstOffset, CharSequence s)	将指定 字符串插入此序列中。
public StringBuilder delete(int start, int end)	移除此序列的子字符串中的字符。
public StringBuilder replace(int start, int end, String str)	使用给定字符串替换此序列的子字符串中的字符。start开始位置、end结束位置。
public int length()	返回长度（字符数）。

 代码演示：

public class Text3 {


		public static void main(String[] args) {
			//StringBuffer sb=new StringBuffer();
            //StringBuilder sb=new StringBuilder("haha");
			StringBuilder sb=new StringBuilder();
			//1 append();追加
			sb.append("java世界第一");
			System.out.println(sb.toString());    //java世界第一
			sb.append("java真香");
			System.out.println(sb.toString());    //java世界第一java真香
			sb.append("java不错");
			System.out.println(sb.toString());    //java世界第一java真香java不错
			//2 insert();添加
			sb.insert(0, "我在最前面");
			System.out.println(sb.toString());    //我在最前面java世界第一java真香java不错
			//3 replace();替换
			sb.replace(0, 5, "hello");
			System.out.println(sb.toString());    //hellojava世界第一java真香java不错
			//4 delete();删除
			sb.delete(0, 5);
			System.out.println(sb.toString());    //java世界第一java真香java不错
			//清空
			sb.delete(0, sb.length());
			System.out.println(sb.length());       //0

		}
}