提示：文章写完后，目录可以自动生成，如何生成可参考右边的帮助文档

文章目录

一、常用类的种类
1.1 内部类
- 成员内部类
- 静态内部类
- 匿名内部类
- 局部内部类
1.2 Object类
1.3 包装类
1.4 String类
总结

一、常用类的种类

常用类：

内部类：成员内部类，静态内部类，局部内部类，匿名内部类
Object类：getClass（）方法，hashCode（）方法，toString（）方法，equals（）方法，finalize（）方法
包装类：类型转换与装箱，拆箱，整数缓冲区
String类
BigDecimal类：Date类，Calendar
System类

1.1 内部类

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

特点：

编译之后可以生成独立的字节码文件
内部类课直接访问外部类私有成员，而不破坏封装
可为外部类提供必要的内部功能组件

代码如下（示例）：

// 身体
class Body{
  // 头部
  class Header{
    // 也会生成class文件
  }
}

成员内部类

在类的内部定义，与实例变量、实例方法同级别的类
外部类的一个实例部分，创建内部类对象时，必须依赖外部类对象
当外部类、内部类存在重名属性时，会优先访问内部类属性
成员内部类里不能定义静态成员、可以包含静态常量(final)

代码如下（示例）：

// 外部类
public class Outer{
  //实例变量
  private String name = "张三";
  private int age = 20;
  //内部类
  class Inner{
    private String address = "北京";
    private String phone = "110";
    private String name = "李四";
    
    //方法
    public void show(){
      //打印外部类属性 此时有重名属性name
      sout(Outer.this.name); // 张三
      sout(age);
      //打印内部类中的属性
      sout(name); // 李四
      sout(address);
      sout(phone);
    }
  }
}

	// 测试类
	public class Test{
	  psvm(String[] args){
	    // 创建外部类对象
	    Outer outer = new Outer();
	    // 创建内部类对象
	    Inner inner = outer.new Inner();
	    //一步到位
	    Inner inner = new Outer.new Inner();
	                            
	    inner.show();
	  }
	}

静态内部类

静态内部类，与外部类相同

代码如下（示例）：

//外部类
public class Test02 {
    //实例变量
    private String name ="张三";
    private int age=20;

    //静态内部类，与外部类相同
    static class Inner{
        private String name="李四";
        private String address="杭州";
        private String phone="110";
        //静态成员
        private static int count=22;

        //方法
        public void show(){
            //打印外部类的属性
            //1.创建外部类对象
            Test02 test02 = new Test02();
            //2.调用外部类对象的属性
            System.out.println(test02.name);
            System.out.println(test02.age);
            //打印内部类的属性
            System.out.println(name);
            System.out.println(address);
            System.out.println(phone);

        }
    }
    
    main方法：
	//静态内部类
		    Test02.Inner inner = new Test02.Inner();
		    inner.show();

匿名内部类

匿名内部类：

1.没有类名的局部内部类

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

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

优点：减少代码量

缺点：可读性较差

代码如下（示例）：

//外部类
public class Test02 {
    //实例变量
    private String name ="张三";
    private int age=20;

    //静态内部类，与外部类相同
    static class Inner{
        private String name="李四";
        private String address="杭州";
        private String phone="110";
        //静态成员
        private static int count=22;

        //方法
        public void show(){
            //打印外部类的属性
            //1.创建外部类对象
            Test02 test02 = new Test02();
            //2.调用外部类对象的属性
            System.out.println(test02.name);
            System.out.println(test02.age);
            //打印内部类的属性
            System.out.println(name);
            System.out.println(address);
            System.out.println(phone);

        }
    }
    
    main方法：
	//静态内部类
		    Test02.Inner inner = new Test02.Inner();
		    inner.show();

局部内部类

局部内部类,不能加任何访问修饰符

代码如下（示例）：

//接口
		public interface Test04 {
		    //服务
		    void service();
		}
		
		//继承
       public class Mouse implements Test04{
		    @Override
		    public void service() {
		        System.out.println("连接电脑成功，鼠标开始工作");
		    }
		    
		//方法
		Test04 test = new Mouse();
        test.service();
        //使用匿名内部类（相当于创建了一个局部内部类）
        Test04 fan = new Test04(){
            @Override
            public void service() {
                System.out.println("连接电脑成功，风扇开始工作");
            }
        };
        fan.service();
}

1.2 Object类

概念：

类 Object 是类层次结构的根类。每个类都使用 Object 作为超类。所有对象（包括数组）都实现这个类的方法。

简单来说就是，Object类是所有类的父类，包括我们所写的类，我们在使用类的时候就会利用Object类中的方法~

一般使用的方法：

getClass（）方法，hashCode（）方法，toString（）方法，equals（）方法，finalize（）方法

代码如下（示例）：

//Student
	public class Student {

    private String name;
    private int age;

    public Student(){

    }
    public Student(String name, int age) {
        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 o) {
        if (this == o) return true;
        if (o == null || getClass() != o.getClass()) return false;
        Student student = (Student) o;
        return age == student.age && Objects.equals(name, student.name);
    }

    @Override
    public int hashCode() {
        return Objects.hash(name, age);
    }

    @Override
    protected void finalize() throws Throwable{
        System.out.println(this.name+"对象被回收了");
    }
}
}

//方法使用
    public class TestStudent {
    public static void main(String[] args) {
        //1.getClass方法
        System.out.println("-------getClass方法------------");
        Student s1 = new Student("aaa",20);
        Student s2 = new Student("bbb",22);
        //判断s1和s2是不是同一个类型
        Class class1 = s1.getClass();
        Class class2 = s1.getClass();
        if (class1==class2){
            System.out.println("属于同类型");
        }else {
            System.out.println("不是同类型");
        }

        //2.hashCode方法
        System.out.println("-------hashCode方法------------");
        System.out.println(s1.hashCode());
        System.out.println(s2.hashCode());

        //3.toString方法
        System.out.println("-------toString方法------------");
        System.out.println(s1.toString());
        System.out.println(s2.toString());

        //4.equals方法，判断两个对象是否相等(地址)
        System.out.println("-------equals方法------------");
        System.out.println(s1.equals(s2));
        Student s3 = new Student("小白",23);
        Student s4 = new Student("小白",23);
        System.out.println(s3.equals(s4));


    }
}

//垃圾回收
public class Teststudent2 {
    public static void main(String[] args) {
//        Student s1 = new Student("aaa",20);
//        Student s2 = new Student("bbb",20);
//        Student s3 = new Student("ccc",20);
//        Student s4 = new Student("ddd",20);
//        Student s5 = new Student("eee",20);
        new Student("aaa",20);
        new Student("bbb",20);
        new Student("ccc",20);
        new Student("ddd",20);
        new Student("eee",20);
        //回收垃圾
        System.gc();
        System.out.println("回收垃圾");
    }
}

1.3 包装类

概念：

Java语言是一个面向对象的语言，但是Java中的基本数据类型却是不面向对象的。基本类型的数据不具备"对象"的特性（没有成员变量和成员方法可以调用），因此，java为每种数据类型分别设计了对应的类，即包装类。

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

特点

（1）所有包装类都是final类型，因此不能创建他们的子类。

（2）包装类是不可变类，一个包装类的对象自创建后，他所包含的基本类型数据就不能被改变。

常用方法

类型转换与装箱，拆箱，整数缓冲区

public class Demo01 {
    public static void main(String[] args) {

        int num=10;
        //类型装换：装箱。基本类型转换成应用类型
        //基本类型
        int num1 =18;
        //使用Interage类创建对象
        Integer integer1 = new Integer(num1);
        Integer integer2 = Integer.valueOf(num1);
        System.out.println("装箱");
        System.out.println(integer1);
        System.out.println(integer2);

        //类型转换：拆箱。引用类型转换为基本类型
        Integer integer3 = new Integer(100);
        int num2 = integer3.intValue();
        System.out.println("拆箱");
        System.out.println(num2);

        //jdk1.5之后，提供自动装箱和拆箱
        int age = 30;
        //自动装箱
        Integer integer4 = age;
        int age2 = integer4;
        System.out.println("自动拆装箱");
        System.out.println(integer4);
        System.out.println(age2);

        System.out.println("-------------转化-----------");
        //1.基本类型和字符串之间的转化
        int n1 = 255;
        //1.1使用+号
        String s1 = n1+"";
        //1.2使用Interger中的toString方法
        String s2 = Integer.toString(n1,16);//radix转化为16进制
        System.out.println(s1);
        System.out.println(s2);

        System.out.println("-------------转化-----------");
        //2.字符串转化为基本类型
        String str = "150";
        int n2 = Integer.parseInt(str);
        System.out.println(n2);

        //boolean字符串转化为基本类型，只有"true"--->true||"true"-->false
        String str2 = "true";
        boolean b1 = Boolean.getBoolean(str2);
        System.out.println(b1);
    }
}

1.4 String类

概念

字符串广泛应用在 Java 编程中，在 Java 中字符串属于对象，Java 提供了 String 类来创建和操作字符串。

String的一些方法：split，replace等练习

public class Demo03 {
    public static void main(String[] args) {
        //字符串的创建（只在池子里面创建了对象）
        String name = "hello";//"hello"存放在字符串池中
        name="张三";//”张三“赋值给了name 给字符串赋值时没有修改数据，而是重新开辟一个空间
        String name2 = "张三";

        //演示字符串的另一种创建方法（会在堆和池子里面创建）
        String str = new String("java");
        String str2 = new String("java");
        System.out.println(str==str2);//false地址指向不同

        //String方法使用
        //1.将str3中的单此单独取出来
        String str3 = "this is a text";
        String[] arr = str3.split(" ");
        System.out.println("-----1.将Str中的单词单独取出来-----");
        for (String s:arr) {
            System.out.println(s);
        }
        //2.将str3中的text替换为practice
        System.out.println("-----2.将Str中的text替换为practice-----");
        String str4 = str3.replace("text","practice");
        System.out.println(str4);
        //3.在text前面插入一个easy
        System.out.println("-----3.在text前面插入一个easy-----");
        String str5 = str3.replace("text","easytext");
        System.out.println(str5);
        //4.将每个单词的首字母改成大写
        System.out.println("-----4.将每个单词的首字母改成大写-----");
        for (int i = 0; i < arr.length; i++) {
            char first = arr[i].charAt(0);
            //把第一个字符转成大写
            char firstUpper = Character.toUpperCase(first);
            String news = firstUpper+arr[i].substring(1);
            System.out.println(news);
        }
    }
}

StringBuffer和StringBuilder的使用和String的区别：

1.效率比String高

2.比String节省内存

StringBuilder和StringBuffer的使用方法一样

建议使用StringBuilder

public class Demo04 {
    public static void main(String[] args) {
        StringBuffer sb = new StringBuffer();
        //1.append(),追加
        sb.append("java");
        System.out.println(sb.toString());
        sb.append("世界第一");
        System.out.println(sb.toString());
        //2.insert(),添加
        sb.insert(0,"第一");
        System.out.println(sb.toString());
        //3.replace()，替换
        sb.replace(0,2,"hello");
        System.out.println(sb.toString());
        //4.delete()，删除
        sb.delete(0,5);
        System.out.println(sb.toString());
        //清空
        sb.delete(0,sb.length());
        System.out.println(sb.length());
    }
}

总结

以上就是今天要讲的内容，本文仅仅简单介绍了内部类和常用类的概念分类以及各个内部类的使用案例

常用类一、常用类的种类1.1 内部类1.2 Object类1.3 包装类1.4 String类总结

文章目录

一、常用类的种类

1.1 内部类

成员内部类

静态内部类

匿名内部类

局部内部类

1.2 Object类

1.3 包装类

1.4 String类

总结

继续阅读

关于Gradle配置的小结

Java小案例——随机数猜测随机数猜测

nginx location中斜线的位置的重要性

27 Best Free Eclipse Plug-ins for Java Developer to be ProductiveCode Quality PluginsText Editor PluginsDependency ManagementVersion Control Integration PluginsFramework Development Continuous Integration Related PluginsOther Utility Plugins

Java String.format方法的简单使用

neo4j之cypher使用文档

GitHub连夜封杀！这份阿里 10W 字内部 Java 字面试手册到底有多强？

spark/scala关于【资源文件】加载方法概述外部文件加载方案测试资源文件打包入jar包中小结

mybatis_入门程序Mybatis入门

AOP编程_Android优雅权限框架(1)概念基础，2021金三银四前言正文大纲正文

Effective Java 8:通用程序设计

OOM三种类型

工厂模式-三种类型

【递归】高效率求2的n次幂

win10本地scala和spark安装安装scala安装spark

scala (3) Function 和 Method