chap11-常用类

---

一.内部类

• 概念

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

    class Outer{
    	class Inner{
    	
    	}
    }
  

  特点：编译后可以生产Outer$Inner.class

  作用：内部类可以直接访问外部类的私有成员，不破坏封装，内部类可以作为外部类提供必要的功能组件

• 内部类的分类：成员内部类、静态内部类、局部内部类、匿名内部类(对比变量)

  • 成员内部类(对比成员变量)

    定义位置：类的内部，方法的外部

    语法：

      class Outer{
      	class Inner{
      	
      	}
      }
    

    创建对象

      //创建外部类对象
      Outer o = new Outer();
      //创建内部类对象---依靠外部类对象
      Outer.Inner i = o.new Inner();
    

    注意：

        外部类成员和内部类成员重名时，优先使用内部类成员

        外部类成员和内部类成员重名时，使用Outer.this.属性/方法()，访问外部类的外部类成员

  • 静态内部类(类变量)

    • 定义位置：类的内部，方法的外部，使用static进行修饰

    • 语法：

        class Outer{
        	static class Inner{
        	}
        }
      

    • 创建对象：

        //依靠外部类类名
        Outer.Inner i = new Outer.Inner();
      

    • 注意：

          静态内部类只能访问外部类的静态成员，不能访问外部类的非静态成员

  • 局部内部类(对比局部变量)

    • 定义位置：方法的内部

    • 语法：

        class Outer{
        	public void m(){
        		class Inner{
      
        		}
        	}
        }
      

    • 创建对象：

        Inner i = new Inner();
      

    • 注意：

          局部内部类访问当前方法的局部变量时，此时局部变量默认final(jdk1.8隐式添加final；需要保证镀锡的生命周期和局部变量的声明周期保持一致)

  • 匿名内部类(特殊的局部内部类)

    • 定义位置：方法内部

    • 语法：(有继承父类或者接口)

        //创建对象和定义类同步完成
        父类名|接口名  对象名 = new 父类名|接口名(){
        		//类的属性
        		//类的方法
        }
      

    • 注意：

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

          创建对象和定义类同步完成

          匿名内部类只能创建一个对象

二.Lambda表达式

• 概念：函数式接口的实现类定义及创建对象的简写形式

• 语法：

    类型  引用名=(参数) ->{方法实现};
    ->左侧：代表接口的实现类的形参
    ->右侧：代表接口实现类的方法实现
  

• 注意:

      如果方法有参数，参数类型可以省略，有系统自动推断出参数类型

      如果参数有一个，小括号也可以省略

      如果方法实现只有一条语句时，可以省略{}

      如果方法只有一个返回值，可以省略return

三.Object类

• 概念：所有类的根类、超类、基类、所有类的直接或者间接父类，如果显示定义父类，隐式继承Object

  • 作用：管理所有数据

    使用Object作为参数；接受Object+所有对象

    使用Object作为返回值；可以返回Object+所有对象

• 常用方法：

  • getClass()：返回运行时类

      ia.getClass()==ca.getClass()//通常用来判断两个引用指向的对象类型是否相同
    

  • hashCode()：返回对象的哈希码值(十进制的地址)

      Integer.toHexString(十进制);//十进制值转十六进制
    

  • toString()：返回对象形式的字符串表示形式

      //toString()通常重写,返回对象的属性值(给开发人员用于测试使用)
      @Override
      public String toString() {
      		return "Worker [name=" + name + ", age=" + age + ", salary=" +salary + "]";
      }
    

  • equals(Object o)：判断两个对象是否相同

      ==:对比基本数据比值;对比对象比地址
      equals()重写前比地址;通常重写比对象内容
      //重写equals()
      public boolean equals(Object obj){
      	//自反性:判断obj是不是当前对象
      	if(this==obj)return true;
      	//非空性:判断参数是否为null
      	if(obj==null)return false;
      	//类型判断:判断当前对象的类型是否参数相同
      	if(this.getClass()!=obj.getClass())return false;
      	//强转 obj转为本类类型
      	Dog d=(Dog)obj;
      //逐一比较属性:引用类型用equals(),基本类型==
      if(this.breed.equals(d.breed)&&this.age==d.age&&this.weight==d.weight)return true;
      	return false;
      }
    

  • finalize()：垃圾回收器(GC)回收垃圾对象时执行的方法

    垃圾对象：没有引用指向的对象

    垃圾回收时机：

      自动回收：当jvm无法为新创建的对象开辟空间时，自动进行垃圾回收
      手动回收：System.gc()，等到程序空闲时执行垃圾回收
    

     

      问题：
      		final、finalize、finally有什么区别？
    

  四.包装类

  • 概念：
    为了使Object可以管理所有的数据包括基本类型，为八种基本类型的数据提供对应的对象类型

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

  • 转换

      // int---->Integer
      int i=10;
      //使用构造方法将int转为Integer
      Integer i1=new Integer(i);
      //使用Integer类中静态valueOf(int)将int转为Integer
      Integer i2 = Integer.valueOf(i);
    
      //Integer---->int
      //使用intValue()将Integer转为int
      int i3 = i1.intValue();
    
      //String---->Integer
      String s="234";
      //使用构造方法将String转为Integer
      Integer i4 = new Integer(s);
      //java.lang.NumberformatException:数字格式异常
      //原因:不是数字类型的值转换为数字
      //使用Integer类中静态valueOf(String)将String转为Integer
      Integer i5 = Integer.valueOf(s);
      
      //Integer---->String
      //使用toString()将Integer转为String
      String s1 = i5.toString();
      String s2=i5+"";
      
      //int---->String
      String s3=i+"";
      
      //String---->int
      //使用Integer类中静态parseInt(String)将String转为int
      int i6 = Integer.parseInt(s);
    

  • 自动装拆箱

    • 从jdk5.0之后，java为基本类型和包装类型的转换提供自动转换机制

        Integer i7=10;//把基本类型转为包装类型-->自动装箱
        int i8=i7;//把包装类型转为基本类型-->自动拆箱
      

  • 数字缓冲区

    把常用的-128~127区间内的256个数字在底层创建一个数组，用于多次使用，数组称为数字缓冲区

      public static Integer valueOf(int i) {
      		//判断i>=-128&&i<=127
      		if (i >= -128 && i <= 127)
      			//返回底层创建数组中的元素
      			return IntegerCache.cache[i + (-IntegerCache.low)];
      		//如果不在范围内重新创建对象进行返回
      		return new Integer(i);
      }	
    

    

    • 作用：用于区分有效数据和无效数据

      所有对象的属性都应该是包装类

      (equals进行比较时,属性逐一比较都是用equals())

五.String类

• 常用方法

    //charAt(int i):返回指定下标i对应的字符
    char c = s.charAt(1);
    System.out.println(c);
    
    //compareTo(String s):比较两个字符串
    System.out.println(s.compareTo(s1));
    
    //contains(String s):判断字符串是否包含子串s
    System.out.println(s.contains("Hello"));
    
    //startsWith(String s):判断字符串是否以s开头
    System.out.println(s.startsWith("Hello"));
    
    //endsWith(String s):判断字符串是否以s结尾
    System.out.println(s.endsWith("ld"));
    
    //indexOf(String s):返回字符串中s第一次出现的下标
    System.out.println(s.indexOf("l"));
    
    //lastIndexOf(String s):返回字符串中s最后一次出现的下标
    System.out.println(s.lastIndexOf("l"));
    
    //length():返回字符串的长度
    System.out.println(s.length());
    
    //isEmpty():判断字符串是否为null
    System.out.println(s1.isEmpty());
    
    //replaceAll(String s1,String s2): 将字符串中所有的S1更换为S2
    System.out.println(s.replaceAll("l", "k"));
    
    //split(String s):以s为界限拆分字符串
    String s2="aa:bb:cc:dd:ee";
    String[] ss = s2.split(":");
    for(int i=0;i<ss.length;i++) {
    	System.out.println(ss[i]);
    }
    
    //substring(int i1,int i2):获取字符串中从i1开始到i2下标之前的字符串
    String s3 = s.substring(2, 5);
    System.out.println(s3);
    
    //toCharArray():将字符串转为字符数组
    char[] cs = s.toCharArray();
    for(int i=0;i<cs.length;i++) {
    	System.out.print(cs[i]+" ");
    }
    System.out.println();
    
    //toLowerCase():把字符串中字母转为小写
    System.out.println(s.toLowerCase());
    
    //toUpperCase():把字符串中字母转为大写
    System.out.println(s.toUpperCase());
    
    //trim():删除字符串前后空格
    String s4="      abc       def               ";
    System.out.println(s4.trim());
  

• 不可变长字符串

  • 一旦创建,长度不可变
    

      问题：String s="Hello"和String s=new String("Hello")的区别?
      答：String s="Hello":创建在串池中,引用指向串池中的Hello,如果串池中存在Hello直接使用,不在创建
      String s=new String("Hello"):new就是在堆空间开辟空间,创建String对象 ,同时查看串池中是否出现Hello,
      如果没有创建Hello对象放在串池里,然后使引用指向堆空间数据,如果串池中存在Hello,无需再串池中创建Hello，
      使引用指向堆空间中创建的对象
    

• 可变长字符串

  使用append进行拼接

    问题：StringBuilder、String、StringBuffer在拼接字符串时的区别?
    答：String:进行拼接时,产生大量中间字符串,影响拼接效率,JDK1.8之后,进行拼接自动使用StringBuilder
    StringBuilder:JDK5.0的产物,线程不安全,效率高
    StringBuffer:JDK1.0的产物,线程安全,效率低
  

 
 
 
 

看完如果对你有帮助，感谢点赞支持！