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

小灰灰 2022-11-12 04:17 205阅读 0赞

# 常用类 #

# 一.内部类 #

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

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

特点：

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

### 成员内部类 ###

>  *  **在类的内部定义，与实例变量、实例方法同级别的类。**
>  *  外部类的一个实例部分，创建内部类对象时，必须依赖外部类对象。
>  *  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)

<table style="width:500px;"> 
 <tbody> 
  <tr> 
   <td style="width:254px;">基本数据类型</td> 
   <td style="width:244px;">包装类型</td> 
  </tr> 
  <tr> 
   <td style="width:254px;">byte</td> 
   <td style="width:244px;">Byte</td> 
  </tr> 
  <tr> 
   <td style="width:254px;">short</td> 
   <td style="width:244px;">Short</td> 
  </tr> 
  <tr> 
   <td style="width:254px;"><span style="color:#f33b45;">int</span></td> 
   <td style="width:244px;"><span style="color:#f33b45;">Integer</span></td> 
  </tr> 
  <tr> 
   <td style="width:254px;"><span style="color:#f33b45;">long</span></td> 
   <td style="width:244px;"><span style="color:#f33b45;">Long</span></td> 
  </tr> 
  <tr> 
   <td style="width:254px;">float</td> 
   <td style="width:244px;">Float</td> 
  </tr> 
  <tr> 
   <td style="width:254px;">double</td> 
   <td style="width:244px;">Double</td> 
  </tr> 
  <tr> 
   <td style="width:254px;">boolean</td> 
   <td style="width:244px;">Boolean</td> 
  </tr> 
  <tr> 
   <td style="width:254px;"><span style="color:#f33b45;">char</span></td> 
   <td style="width:244px;"><span style="color:#f33b45;">Character</span></td> 
  </tr> 
 </tbody> 
</table>

## 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.常用方法 ##

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

代码：

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：可变长字符串，运行效率慢，线程安全。（字符串短，运行慢，安全）

<table> 
 <tbody> 
  <tr> 
   <th style="width:372px;">方法名</th> 
   <th style="width:389px;">属性</th> 
  </tr> 
  <tr> 
   <td style="width:372px;">public StringBuilder append(String str)</td> 
   <td style="width:389px;">追加内容。</td> 
  </tr> 
  <tr> 
   <td style="width:372px;">public StringBuilder insert(int dstOffset, CharSequence s)</td> 
   <td style="width:389px;">将指定 字符串插入此序列中。</td> 
  </tr> 
  <tr> 
   <td style="width:372px;">public StringBuilder delete(int start, int end)</td> 
   <td style="width:389px;">移除此序列的子字符串中的字符。</td> 
  </tr> 
  <tr> 
   <td style="width:372px;">public StringBuilder replace(int start, int end, String str)</td> 
   <td style="width:389px;">使用给定字符串替换此序列的子字符串中的字符。start开始位置、end结束位置。</td> 
  </tr> 
  <tr> 
   <td style="width:372px;">public int length()</td> 
   <td style="width:389px;">返回长度（字符数）。</td> 
  </tr> 
 </tbody> 
</table>

代码演示：

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
    
    		}
    }