Java 面向对象

最新推荐文章于 2024-06-14 15:02:13 发布

小小印z

最新推荐文章于 2024-06-14 15:02:13 发布

阅读量409

点赞数 1

分类专栏： Java基础文章标签： java 开发语言

本文链接：https://blog.csdn.net/weixin_49561506/article/details/129737860

版权

Java基础专栏收录该内容

4 篇文章 0 订阅

订阅专栏

一、Java 8 增强的包装类

Java是面向对象的编程语言，但它也包含了8种基本数据类型，这8种基本数据类型不支持面向对象的编程机制，基本数据类型的数据也不具备对象的特性。（没有成员变量、方法可以被调用）。Java之所以提供这8种数据类型，主要是为了照顾程序员的传统习惯。

基本数据类型的限制：

所有的引用类型的变量都继承了Object类，都可以当成Object类型变量使用。但基本数据类型的变量就不可以。

解决办法：

为了解决8种基本数据类型不能当成Object类型变量使用的问题，Java提供了包装类的概念，为8种基本数据类型发呢别定义了相应的引用类型。

对应关系：

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

自动装箱：

可以把一个基本类型变量直接赋给对应的包装类变量，或者赋给Object变量。

自动拆箱：

允许直接把包装类对象赋给一个对应的基本类型变量。

public class AutoBoxingUnboxing {

    public static void main(String[] args) {

        //自动装箱：
        //直接把一个基本类型变量赋给Integer对象
        Integer inObj = 5;

        //直接把一个boolean类型变量献给一个Object类型的变量
        Object boolObj = true;

        //自动拆箱：直接把一个Integer对象赋值给int类型的变量
        int a = inObj;

        if (boolObj instanceof Boolean) {
            //先把Object对象强制类型转换为Boolean类型，再赋给boolean对象
            boolean b = (Boolean)boolObj;
            System.out.println(b);
        }
    }
}

字符串类型——> int 类型：

        String str = "123";
        int b = Integer.parseInt(str);
        int c = new Integer(str);
        System.out.println("b="+b);
        System.out.println("c="+c);

int 类型——> String类型

        String s = String.valueOf(b);
        System.out.println(s.getClass());

        //或者直接和空串相连
        String ss = c + "";
        System.out.println(ss.getClass());

注意问题：

这是因为在 -128~127之间的数字，同一个整数自动装箱成Integer实例时，引用的是cache数组的同一个数组元素，所以它们全都相等。而不在这个范围内的，每次自动装箱的时候都会新创建一个Integer实例，所以两个会不相等。

        Integer ia = 2;
        Integer ib = 2;
        System.out.println(ia == ib); //true

        Integer ic = 128;
        Integer id = 128;
        System.out.println(ic == id);  //false

二、处理对象

1. 打印对象和 toString 方法

对于一个Person对象 p，使用这两种方式效果一样：

System.out.println(p);
System.out.println(p.toString());

Object类提供的 toString() 方法总是返回该对象实现类的“类名+@+hashCode”。

2. == 和 equals方法

== ：如果两个变量是基本类型变量，且都是数值类型，只要两个变量的值相等，就返回true。但是对于两个引用类型变量，只有它们指向同一个对象时，==判断才会返回true。

equals：equals() 方法是Object 类提供的一个实例方法，因此所有引用变量都可以调用该方法来判断是否与其他引用变量相等，但是使用这个方法判断两个对象相等的标准与使用==运算符没有区别，同样要求引用变量指向同一个对象才会返回true。更多情况我们都选择重写equals方法。

注意：String类已经重写了equals()方法。

例如：

    public boolean equals(Object obj) {
        if (this == obj) {
            return true;
        }
        if (obj != null && obj.getClass() == Person.class) {
            Person personObj = (Person)obj;
            if (this.getId().equals(personObj.getId())) {
                return true;
            }
        }
        return false;
    }

三、final修饰符

final关键字可用于修饰类、变量和方法。final修饰变量时，表示该变量一旦获得初始值就不可被改变。

1. final成员变量

成员变量随类初始化或对象初始化而初始化的，final修饰的成员变量必须由程序员显式地指定初始值。

2. final局部变量

系统不会对局部变量进行初始化，局部变量必须由程序员显式初始化，因此使用final修饰局部变量时，既可以在定义时指定默认值，也可以不指定默认值。

3. final修饰基本类型变量和引用类型变量的区别

final修饰基本类型变量时，不能对基本类型变量重新赋值，但对于引用类型变量而言，它保存的仅仅是一个引用，final只保证这个引用类型变量所引用的地址不会改变，即一直引用同一个对象，但是这个对象完全可以发生改变。

4. final类

final类不能有子类，Java.lang.Math就是一个final类。

四、抽象类

当编写一个类时，常常会为该类定义一些方法，这些方法用以描述该类的行为方式，那么这些方法都有具体的方法体。但是有的类只知道其子类应该包含什么样的方法，但不知道具体内容，这就是抽象类。抽象方法是只有方法的定义，没有具体实现的方法。

1. 抽象方法和抽象类

抽象方法和抽象类必须用 abstract 修饰。规则如下：

抽象方法不能有方法体
抽象类不能被实例化，不能new
抽象类可以包含成员变量、方法、构造器、初始化块、内部类5种成分。抽象类的构造器不能创建实例，主要是用于被其子类调用
含有抽象方法的类只能被定义为抽象类

当使用 static 修饰一个方法时，表明这个方法属于该类本身，即通过类就可以调用该方法。static和abstract不能同时修饰某个方法，但是它们可以同时修饰内部类。

abstract 修饰的方法不能被定义为private，因为它需要被重写。

2. 抽象类的作用

抽象类体现的就是一种模板模式的设计，抽象类作为多个子类的通用模板，子类在抽象类的基础上进行扩展、改造，但子类总体上会大致保留抽象类的行为方式。

如果编写一个抽象父类，父类提供了多个子类的通用方法，并把一个或多个方法留给其子类实现，这就是一种模板模式，模板模式也是十分常见且简单的设计模式之一。

五、Java 8 改进的接口

抽象类是从多个类种抽象出来的模板，如果将这种抽象进行的更彻底，则可以提炼出一种更加特殊的“抽象类”——接口，接口里不能包含普通方法，接口里的所有方法都是抽象方法，Java8对接口进行了改进，允许在接口种定义默认方法，默认方法可以提供方法实现。

接口里不能包含构造器和初始化块定义，接口里可以包含成员变量（只能是静态常量），方法（只能是抽象方法、类方法或默认方法）、内部类（包含内部接口、枚举）定义。

在接口里下面两行代码含义一样：

int MAX_SIZE = 50;
public static final int MAX_SIZE = 50;

1. 接口的继承

interface interfaceC extends interfaceA, interfaceB{}

2. 接口的作用

定义变量，也可用于进行强制类型转换
调用接口种定义的常量
被其他类发现

实现接口：

修饰符 class 类名 extends 父类 implements 接口1，接口2{}

3. 接口和抽象类

接口和抽象类很像，他们都具有如下特征：

接口和抽象类都不能被实例化，他们都位于继承树的顶端，用于被其他类实现和继承
接口和抽象类都可以包含抽象方法，实现接口或继承抽象类的普通子类都必须实现这些抽象方法。

接口和抽象类的区别：

接口里不包含构造器；抽象类里可以包含构造器，抽象类里的构造器并不是用于创建对象，而是让其子类调用这些构造器来完成属于抽象类的初始化操作
接口里不能包含初始化块，抽象类可以包含

六、内部类

大部分时候，类被定义为一个独立的程序单元，在某些情况下，也会把一个类放在另一个类的内部定义，这个定义在其他类内部的类就被称为内部类。

1. 内部类作用

内部类提供了更好的封装，可以把内部类隐藏在外部类之内，不允许同一个包种的其他类访问该类。如Cow类和CowLeg类，CowLeg只有在Cow类里面才有意义，所以可以把他定义在Cow里面当作内部类。
内部类成员可以直接访问外部类的私有数据，因为内部类被当作其外部类成员。
匿名内部类适合用于创建那些仅需要一次使用的类。

2. 非静态内部类

定义内部类：

public class OuterClass {
    private class interClass{}
}

如果外部类需要访问非静态内部类的成员，则必须显示创建非静态内部类对象来调用访问其实例成员。

3. 静态内部类

如果用static修饰一个内部类，则这个内部类就属于外部类本身，而不属于外部类的某个对象。因此用static修饰的内部类被称为类内部类。

static的作用是把类的成员变成类相关，而不是实例相关。即static修饰的成员属于整个类，而不属于单个对象。

4. 局部内部类

如果把一个内部类放在方法里定义，则这个内部类就是一个局部内部类，局部内部内仅在方法里有效。

5. 匿名内部类

匿名内部类适合创建那种只需要一次使用的类，创建匿名内部类时会创建以恶该类的实例，这个类定义立即消失，匿名内部类不能重复使用。

示例：

public interface MyInterface {
    void doSomething();
}

public class MyClass {
    public static void main(String[] args) {
        // 创建一个实现MyInterface接口的匿名内部类
        MyInterface myInterface = new MyInterface() {
            @Override
            public void doSomething() {
                System.out.println("Doing something...");
            }
        };

        // 调用doSomething方法
        myInterface.doSomething();
    }
}

在上述示例中，我们定义了一个接口MyInterface和一个类MyClass。在MyClass中的main方法中，我们使用匿名内部类创建了一个实现MyInterface接口的对象。在这个匿名内部类中，我们重写了MyInterface中的doSomething方法，当调用myInterface.doSomething()时，它将输出Doing something...。

匿名内部类必须继承一个父类，或实现一个接口，但最多只能继承一个父类，或实现一个接口。

6. 枚举类

在某些情况下，一个类的对象是有限而且固定的，比如季节类，它只有四个对象。这种实例有限而且固定的类，在Java里被称为枚举类。

定义一个季节的枚举类：

public enum Season {
    SPRING,
    SUMMER,
    AUTUMN,
    WINTER
}

使用枚举类：

public class Main {
    public static void main(String[] args) {
        Season currentSeason = Season.SPRING;
        System.out.println("当前季节是：" + currentSeason);

        switch (currentSeason) {
            case SPRING:
                System.out.println("现在是春天");
                break;
            case SUMMER:
                System.out.println("现在是夏天");
                break;
            case AUTUMN:
                System.out.println("现在是秋天");
                break;
            case WINTER:
                System.out.println("现在是冬天");
                break;
        }
    }
}

输出：

当前季节是：SPRING
现在是春天

7. 对象与垃圾回收

Java垃圾回收时Java语言的重要功能之一。当程序创建对象、数组等引用类型实体时，系统都会在堆内存中为之分配一块内存区，对象就保存在这块内存区中，当这块内存不再被任何引用变量引用时，这块内存就变成垃圾，等待垃圾回收机制进行回收。垃圾回收机制具有如下特征：

垃圾回收机制只负责回收堆内存中的对象，不会回收任何物理资源（如数据库连接、网络和IO）
程序无法精确控制垃圾回收的运行，垃圾回收会在合适的时候进行。当对象永久性的失去引用后，系统就会在合适的时候回收它所占的内存。
在垃圾回收机制回收任何对象之前，总会先调用它的finalize() 方法。

强制垃圾回收：

在Java中，我们不能确保垃圾回收器什么时候会执行，因为这是由JVM自行管理的。但是，我们可以通过调用System.gc()或者Runtime.getRuntime().gc()方法来提示垃圾回收器尽快执行垃圾回收操作。

需要注意的是，虽然调用System.gc()或者Runtime.getRuntime().gc()方法可以请求垃圾回收器进行垃圾回收操作，但是它们不能保证垃圾回收器一定会执行。这是因为JVM在进行垃圾回收时有可能会优化执行时间，避免过多频繁的垃圾回收操作，因此，这些方法调用只能作为提示，而不能作为强制垃圾回收的手段。

同时，需要注意的是，在实际应用中，应该避免频繁地调用垃圾回收操作，因为这会占用系统资源，影响程序的性能。通常情况下，我们可以通过优化程序代码、避免创建过多无用的对象等方式来减少垃圾回收的执行次数，提高程序的性能。