Java学习第五章-内部类与常用类（String，包装类）

最新推荐文章于 2024-04-25 12:25:03 发布

langMR

最新推荐文章于 2024-04-25 12:25:03 发布

阅读量351

点赞数

分类专栏： Java学习笔记文章标签：字符串 java

本文链接：https://blog.csdn.net/langMR/article/details/107349872

版权

Java学习笔记专栏收录该内容

29 篇文章 0 订阅

订阅专栏

什么是内部类

概念

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

特点

编译之后可生成独立的字节码文件。

Outer$Inner.class

内部类可直接访问外部类的私有成员，而不破坏封装。
可为外部类提供必要的内部功能组建。

成员内部类

在类的内部定义，与实例变量、实例方法同级别的类。
外部类的一个实例部分,创建内部类对象时,必须依赖外部类对象。

Outer out= new Outer(); 
Outer.Inner in= out.new Inner();

当外部类、内部类存在重名属性时,会优先访问内部类属性。
若要访问外部类的内容可以通过

外部类名.this.属性值

成员内部类不能定义静态成员,可以包含静态常量。

静态内部类

不依赖外部类对象，可直接创建或通过类名访问，可声明静态成员
只能直接访问外部类的静态成员（实例成员需实例化外部类对象），级别和外部类相同，给外部类提供功能。

局部内部类

定义在方法里面的，外部类的方法当中。作用范围和创建对象范围仅限于方法内。
类上不可以加任何访问修饰符。其内部的成员不可以是静态的，但可以加final，成为静态常量。

puublic class Outer{
	private String name="asd";
	private int age=35;
	public void show(){
		String address="dsa";
		class Inner{
		private String phone="15211111111";
		private String email="asd@qq.com";
		public void show2(){
			System.out.println(name);//可以直接访问外部类的实例属性，它属于方法中的内部类
			System.out.println(address);//jdk1.7当中要求必须是常量。1.8的时候可以省略final也就是他在
			//address前面某人加了final，即address不可以修改，相当于address是常量。因为方法完事之后
			//局部变量回消失，但是Inner类不会消失，因此必须是常量。
		}
		}
		Inner inner=new Inner();
		inner.show2();
	}
}

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

匿名内部类

没有类名的局部内部类（一切特征都与局部内部类相同）。
必须继承一个父类或者实现一个接口。
定义类、实现类、创建对象的语法合并,只能创建一个该类的对象。
优点:减少代码量。
缺点:可读性较差。

Usb usb=new Usb(){ //Usb接口中的方法重写代码}

常见类

Object

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

getClass()方法

public final Class<?> getClass(){}
返回引用中存储的实际对象类型
应用：通常用于判断两个引用中实际存储对象类型是否一致。

public class asd {
    public static void main(String[] args) {
        TestInterface ee=new test1();
        TestInterface e1=new test1();
       if( ee.getClass()==e1.getClass() )
       {
           System.out.println("ok");
       }else
       {
           System.out.println("no");
       }
    }
}

输出结果为ok

hashCode（）方法

public int hashCode{}
返回该对象的十进制的哈希码值。
哈希算法根据对象的地址或字符串或数字计算出来的int类型的数值。
哈希码并不唯一,可保证相同对象返回相同哈希码,尽量保证不同对象返回不同哈希码。
可用于检验对象是否是同一个（通过地址演算出的哈希码）

toString（）方法

public String toString(){ }
返回对象的类型和十六进制的哈希值
返回该对象的字符串表示（表现形式）。
可以根据程序需求覆盖该方法,如:展示对象各个属性值。
此方法可以在idea中通过alt+insert 快捷键生成toString的覆盖。

equals（）方法

public boolean equals(Object obj){}
默认实现为(this==obj）,比较两个对象地址是否相同。
可进行覆盖,比较两个对象的内容是否相同。
如果没有对equals方法进行重写，则比较的是引用类型的变量所指向的对象的地址值是否一样,和==一样；
如果对equals方法重写了,如String、Date等类对equals方法进行了重写，比较的是所指向的对象的内容是否相同。

equals(）方法覆盖步骤

比较两个引用是否指向同一个对象。
判断obj是否为null。
判断两个引用指向的实际对象类型是否一致。
强制类型转换。
依次比较各个属性值是否相同。

public class asd {
    private String name;
    @Override
    public boolean equals(Object obj) {
        if(this==obj){
            return true;
        }
        if(obj==null){
            return false;
        }
        if(obj instanceof asd){
           asd s=(asd)obj;
           if(this.name.equals(s.getName())){
               return true;
           }

        }
        return false;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }
}

finalize()方法

当对象被判定为垃圾对象时,由JVM自动调用此方法,用以标记垃圾对象, 进入回收队列。
垃圾对象:没有有效引用指向此对象时,为垃圾对象。
垃圾回收:由GC销毁垃圾对象,释放数据存储空间。
自动回收机制:JVM的内存耗尽,一次性回收所有垃圾对象。
手动回收机制:使用System.gc(）;通知JVM执行垃圾回收。

包装类

基本数据类型所对应的引用数据类型。
Object可统一所有数据,包装类的默认值是null。
基本数据类型在栈里面，引用数据类型在堆里面

Byte

对应基本类型的byte，当创建对象后Byte会在堆里面创建对象，而基本数据类型byte会在栈里面开辟空间。

Integer

对应基本类型int，
构造方法：Integer(int i)，Integer(String s)

常用的方法：
- int intValue()变为基本类型
- static int parseInt(String s)\static int parseInt(String s,int radix)
- static Integer valueOf(int i) 返回一个表示指定的int值的Integer实例。

类型转换与装箱、拆箱

也就是栈中的基本数据类型转换成堆中的引用类型，反过来就是拆箱。
8种包装类提供不同类型间的转换方式:

Number父类中提供的6个共性方法。
- 拆箱：XXXValue();转换成基本数据类型
- 装箱：各自的构造方法还有XXX.valueOf（）；
parseXXX（）静态方法（除了Character）。字符串和基本类型的转换
valueOf（）静态方法。
注意:需保证类型兼容,否则抛出NumberFormatException异常。
JDK 5.0之后,自动装箱、拆箱。基本数据类型和包装类自动转换。

整数缓冲区

Java预先创建了256个常用的整数包装类型对象。  在实际应用当中,对已创建的对象进行复用。

public class asd {
    public static void main(String[] args) {
        Integer integer=new Integer(100);
        Integer integer1=new Integer(100);
        System.out.println(integer==integer1); //false
        Integer integer2=100;
        Integer integer3=100;
        System.out.println(integer2==integer3);//true
        Integer integer4=200;
        Integer integer5=200;
        System.out.println(integer4==integer5);//false
    }
}

在基本类型转换成Integer时-128~127之间的数已经被声明好了，所以当我将基本整形转换成Integer他就会去Integer缓冲区中找，如果是上面的区间，那么引用的就是同一个地址的，而大于这个区间的就会新new一个对象，这样地址就不同，所以比较之后不相等。

String类

字符串是常量，创建之后不可改变，改变的是指向的字符串池中的地址，相当于又在方法区（字符串池)中新建了一个空间，且之前的数据还在方法区中，如果有其他变量指向该常量值会指向已存在的常量的地址。
字符串字面值存储在字符串池中（常量池），可以共享。（除了栈和堆还有一个地区叫方法区，字符串池就在方法区中，目的是为了共享）
String str1=“Hello”;  这个产生一个，在字符串池中存储
String str2= new String(“World”); 这个产生两个，因为被new出来所以一个存在了堆中，一个存在了字符串池中。先字符串池，后堆中，栈指向堆，堆中指向池中，堆中是没有值的。

jdk1.7之前：方法区位于永久代(PermGen)，永久代和堆相互隔离，永久代的大小在启动JVM时可以设置一个固定值，不可变；
jdk.7：存储在永久代的部分数据就已经转移到Java Heap或者Native memory。但永久代仍存在于JDK
1.7中，并没有完全移除，譬如符号引用(Symbols)转移到了native memory；字符串常量池(interned strings)转移到了Java heap；类的静态变量(class statics variables )转移到了Java heap；
jdk1.8：仍然保留方法区的概念，只不过实现方式不同。取消永久代，方法存放于元空间(Metaspace)，元空间仍然与堆不相连，但与堆共享物理内存，逻辑上可认为在堆中。

1）移除了永久代（PermGen），替换为元空间（Metaspace）； 2）永久代中的 class metadata 转移到了
native memory（本地内存，而不是虚拟机）； 3）永久代中的 interned Strings 和 class static
variables 转移到了 Java heap； 4）永久代参数（PermSize MaxPermSize） ->
元空间参数（MetaspaceSize MaxMetaspaceSize）。转载至
https://blog.csdn.net/qq_41872909/article/details/87903370

常用方法

public int length():返回字符串长度
public char charAt(int index);查看指定位置的字符
public boolean contains(String s)；看是否存在s
public char[] toCharArray():将字符串转换成数组
public int indexOf（String str）：查找str首次出现的下标，存在返回下标。
public int lastindexOf（String str）：查找str最后一次出现的下标，存在返回下标。
·publicString trim(）:去掉字符串前后的空格。 ·
public String toUpperCase0:将小写转成大写。
public String toLowerCase0:将大写转成小写。
public boolean endWith（String str）:判断字符串是否以str结尾。
public String replace（char oldChar,char newChar）:将旧字符串替换成新字符串
public String[l split(String str）):根据str做拆分。

split("[ ,]+"）；可以通过空格还有，号拆分字符串，并且后面的+代表可以1或多个空格和+号

public String substringint beginIndex,int endiIndex）:在字符串中截取出一个子字符串
equals、判断是否相等
compareTo（）；比较大小，返回值是首字母字母ascall码值相减，或者前几个字符相同时长度不一样会比较长度

可变字符串

概念:可在内存中创建可变的缓冲空间,存储频繁改变的字符串。 
常用方法: · public StringBuilder append(String str) 
StringBuilder:可变长字符串,JDK5.0提供,运行效率快、线程不安全。 
StringBuffer:可变长字符串,JDK1.0提供,运行效率慢、线程安全。 先开辟一个缓冲区，然后再缓存区上操作。
相对于String，他们俩效率比String高，比String节省内存
方法：

append（）-追加方法
insert（int offset,String s）在指定位置添加字符串
replace (int start,int end,String str);替换指定位置
delete(int start ,int end);删除
reverse()反转

通过代码看效率

public class asd {
    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("用时"+(end-start));
        long start=System.currentTimeMillis();
        StringBuilder stringBuilder=new StringBuilder();
        for(int i=0;i<99999;i++){
            stringBuilder.append(i);
        }
        System.out.println(stringBuilder.toString());
        long end=System.currentTimeMillis();
        System.out.println("用时"+(end-start));
    }
}

最后一个输出20多秒，一个0.016秒

BigDecimal

public class asd {
    public static void main(String[] args) {
        double d1=1.0;
        double d2=0.9;
        System.out.println(d1-d2);
    }
}

输出结果为：0.09999999999999998

原因出现在double的存储的方式，他是采用近似值的存储方法。此种方法在对精度较高的程序中不适用
精度高一些的就是BigDecimal，它是精确存储的。

位置: java.math包中。
作用:精确计算浮点数。
创建方式:BigDecimal bd=new BigDecimal(“1.0”); ·方法: ·
- BigDecimal add(BigDecimal bd)加
- BigDecimal subtract(BigDecimal bd)减
- BigDecimal multiply(BigDecimal bd)乘
- BigDecimal divide(BigDecimal bd) 除  此方法如果没给除不净的数保留的小数位数会报错
  - new BigDecimal(“10”).divide(new BigDecimal(“3”),2,BigDecimal.ROUND_HALF_UP);

·除法:BigDecimal(BigDecimal bd,int scal, RoundingMode mode) ·参数scale:指定精确到小数点后几位。 ·参数mode: ·指定小数部分的取舍模式,通常采用四舍五入的模式, ·取值为BigDecimal.ROUND_HALF_UP。

Date类

Date表示特定的瞬间,精确到毫秒。 Date类中的大部分方法都已经被Calendar类中的方法所取代。 
时间单位 ·1秒=1000毫秒  1毫秒=1000微秒 ·1微秒=1000纳秒
计算其中的标准基准时间为 1970年1月1日
没有过时的方法
after
before(Date when)测试是否在指定日期之前
clone（）放回对象的副本
compareTo（Date anotherday）比较两个日期的顺序
equals（Object obj)
getTime() 返回自1970年1月1日到现在的毫秒数
setTime(long time) 返回自1970年1月1日之后time毫秒的时间点
toString（）返回美式日期

Calendar

Calendar提供了获取或设置各种日历字段的方法
protected Calendar()构造方法为protected修饰,无法直接创建该对象

在这里插入图片描述

public class asd {
    public static void main(String[] args) {
        //创建Calendar对象
        Calendar calendar=Calendar.getInstance();
        System.out.println(calendar.getTime().toString());

        //获取时间信息
        int year=calendar.get(Calendar.YEAR);
        int month=calendar.get(Calendar.MONTH);
        int day=calendar.get(Calendar.DAY_OF_MONTH);
        int hour=calendar.get(Calendar.HOUR_OF_DAY);//24小时
        int minute=calendar.get(Calendar.MINUTE);
        int second=calendar.get(Calendar.SECOND);
        System.out.println(year+" "+(month+1)+" "+day+" "+hour+" "+minute+" "+second);
        System.out.println(calendar.getActualMaximum(Calendar.DAY_OF_MONTH));//输出为31，获取这个月中最后一天
        System.out.println(calendar.getActualMinimum(Calendar.DAY_OF_MONTH));
    }
}

输出当前时间，month获取的是从0-11记录的所以要+1。

SimpleDateFormat

SimpleDateFormat是以与语言环境有关的方式来格式化和解析日期的类。 
进行格式化（日期->文本）、解析（文本->日期）。
在这里插入图片描述

public class asd {
    public static void main(String[] args) {
        //创建
        SimpleDateFormat simpleDateFormat=new SimpleDateFormat("yyyy年MM月dd日 HH：mm:ss");
        //创建date
        Date date=new Date();
        //格式化date
        String string=simpleDateFormat.format(date);
        System.out.println(string);
         //字符串解析成日期
        System.out.println(simpleDateFormat.parse("1990年2月1日 00：00:00"));//格式必须对上要不报错
    }
}