java基础回顾_06(自用）

最新推荐文章于 2025-05-28 15:51:16 发布

一根想学会敲代码的薯条

最新推荐文章于 2025-05-28 15:51:16 发布

阅读量63

点赞数

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

本文链接：https://blog.youkuaiyun.com/m0_63577901/article/details/133237849

版权

java基础专栏收录该内容

7 篇文章

订阅专栏

面向对象特征：多态性

一种事务的多种形态

父类的引用指向子类的对象

声明父类，new 了子类

适用于方法，不适用于属性

public class person {
    String name;
    int age;
    public void eat(){
        System.out.println("人吃饭");
    }
    public void sleep(){
        System.out.println("人睡觉");
    }
}

public class Man extends person{
    boolean isSmoking;
    @Override
    public void eat(){
        System.out.println("男的吃肉a");
    }
    @Override
    public void sleep(){
        System.out.println("男的睡觉");
    }
}

public class Woman extends  person{
    boolean isBeauty;
    @Override
    public void eat(){
        System.out.println("女的爱吃啥都行");
    }
    public void walk(){
        System.out.println("女孩走路");
    }
    public void goShopping(){
        System.out.println("女人喜欢逛街...");
    }
}

public class Main {
    public static void main(String[] args){
        person p1=new person();
        Man m1=new Man();
        //多态性
        person p2=new Man();
        //应用：虚拟方法调用
        p2.eat();//表现出Man类特点
        /*
        在堕胎场景下，调用方法时
        编译时，认为方法是左边声明的父类的类型的方法
        执行时，实际执行的是子类重写父类的方法
         */
    }
}

向上转型和向下转型

向下转型，建议使用instance of 进行判断

public class Main {
    public static void main(String[] args){
        person p1=new person();
        Man m1=new Man();
        person p2=new Woman();
        /*
        *1.建议向下转型之前使用instanceof进行判断，避免出现类型转换异常
        * 2.格式：a instance of A:判断a 是不是类A的实例
         */
        if(p2 instanceof Man){
            Man m2=(Man)p2;
            m2.eat();
        }
        if(p2 instanceof Woman){
            System.out.println("WOMAM");
        }
    }
}

Object类

类 java.lang.Object 是类层次结构的根类，即所有其它类的父类。每个类都使用 Object 作为超类。

所以Object定义的结构，所有的类都可以使用，比较有通用性

Object的方法：

equals()

基本类型比较值:只要两个变量的值相等，即为 true。
int a=5;
if(a==6){…}
• 引用类型比较引用(是否指向同一个对象)：只有指向同一个对象时，==才返回 true。
Person p1=new Person();
Person p2=new Person();
if (p1==p2){…}
– 用“==”进行比较时，符号两边的数据类型必须兼容 (可自动转换的基本数据类型除外)，否则编译出错

==和 equals 的区别

• == 既可以比较基本类型也可以比较引用类型。对于基本类型就是比较值，对于引用类型就是比较内存地址
• equals 的话，它是属于 java.lang.Object 类里面的方法，如果该方法没有被重写过默认也是==;我们可以看到 String 等类的 equals 方法是被重写过的，而且 String 类在日常开发中用的比较多，久而久之，形成了 equals 是比较值的错误观点。
• 具体要看自定义类里有没有重写 Object 的 equals 方法来判断。通常情况下，重写 equals 方法，会比较类中的相应属性是否都相等

toString()

默认情况下，toString返回的是“对象运行时类型@对象的hashCode值的十六进制形式

在进行String与其他类型数据的连接操作时，自动给调用toString方法

clone()

public class CloneTest {
public static void main(String[] args) {
    Animal a1 = new Animal("花花");
    try {
        Animal a2 = (Animal) a1.clone();
        System.out.println("原始对象：" + a1);
        a2.setName("毛毛");
        System.out.println("clone 之后的对象：" + a2);
    } catch (CloneNotSupportedException e) {
         e.printStackTrace();
    }
}
}

a1.clone()返回的是Object类型的

finalize()

• 当对象被回收时，系统自动调用该对象的 finalize() 方法。（不是垃圾回收器调用的，
是本类对象调用的）
– 永远不要主动调用某个对象的 finalize 方法，应该交给垃圾回收机制调用。
• 什么时候被回收：当某个对象没有任何引用时，JVM 就认为这个对象是垃圾对象，就
会在之后不确定的时间使用垃圾回收机制来销毁该对象，在销毁该对象前，会先调用
finalize()方法。
• 子类可以重写该方法，目的是在对象被清理之前执行必要的清理操作。比如，在方法
内断开相关连接资源。
– 如果重写该方法，让一个新的引用变量重新引用该对象，则会重新激活对
象。
在 JDK 9 中此方法经被标记为过时的。

getClass()

public final Class<?> getClass()：获取对象的运行时类型

hashCode()

public int hashCode()：返回每个对象的 hash 值。

native关键字

static关键字

如果想让一个成员变量被类的所有实例共享，就用 static 修饰计科，称为类变量或类属性

使用范围：
– 在 Java 类中，可用 static 修饰属性、方法、代码块、内部类
• 被修饰后的成员具备以下特点：
– 随着类的加载而加载
– 优先于对象存在
– 修饰的成员，被所有对象所共享
– 访问权限允许时，可不创建对象，直接被类调用

static修饰的成员变量就是静态变量

static修饰的成员方法就是静态方法

•静态方法可以被子类继承，但不能被子类重写。

只要权限修饰符允许，静态方法在其他类中可以通过“类名.静态方法“的方式调用。也可以通过”对象.静态方法“的方式调用（但是更推荐使用类名.静态方法的方式）。

单例设计模式

设计模式是在大量的实践中总结和理论化之后优选的代码结构、编程风格、以及解决问题的思考方式。设计模式免去我们自己再思考和摸索。就像是经典的棋谱，不同的棋局，我们用不同的棋谱。"套路"

经典的设计模式共有23种。每个设计模式均是在特定环境下特定问题的处理方法

单例模式，就是采取一定的方法保证在整个软件体系中，对某个类只能存在一个对象示例，并且该类只提供一个取得对象实例的方法

实现思路

如果我们要让类在一个虚拟机中只能产生一个对象，我们首先必须将类的构造器的访问权限设置为 private ，这样，就不能用 new 操作符在类的外部产生类的对象了，但在类内部仍可以产生该类的对象。因为在类的外部开始还无法得到类的对象，只能调用该类的某个静态方法以返回类内部创建的对象，静态方法只能访问类中的静态成员变量，所以，指向类内部产生的该类对象的变量也必须定义成静态的

//饿汉式
public class BankTest {
    public static  void  main(String[] args){
        Bank bank1=new Bank();
        Bank bank2=new Bank();
    }

}
class Bank{
    //1.类的构造私有化
    private Bank(){
    }
    //2.在类的内部创建当前类的实例
    //4.此属性也必须声明为static
    private static Bank istance =new Bank();

    //3.使用getXXX()方法获取当前类的实例，必须声明为static
    public static Bank  getInstance(){
        return istance;
    }

}

//懒汉式
public class GirlFriendTest {
    public static void main(String[] args){

    }
}
class GirlFriend(){

    //1.类的构造实例化
    private GirlFriend(){

    }
    //2.声明当前实例
    //4.此属性也必须为static
    private static GirlFriend instance=null;
    //3.通过getXXX()获取实例，则在方法内部进行创建

     public static GirlFriend getInstance(){
         if(instance==null){
             instance=new GirlFriend();
         }
         return instance;
     }
}

饿汉式：
• 特点：立即加载，即在使用类的时候已经将对象创建完毕。
• 优点：实现起来简单；没有多线程安全问题。
• 缺点：当类被加载的时候，会初始化 static 的实例，静态变量被创建并分配内存空间，从这以后，这个 static 的实例便一直占着这块内存，直到类被卸载时，静态变量被摧毁，并释放所占有的内存。因此在某些特定条件下会耗费内存。
懒汉式：
• 特点：延迟加载，即在调用静态方法时实例才被创建。
• 优点：实现起来比较简单；当类被加载的时候，static 的实例未被创建并分配内存空间，当静态方法第一次被调用时，初始化实例变量，并分配内存，因此在某些特定条件下会节约内存。
• 缺点：在多线程环境中，这种实现方法是完全错误的，线程不安全，根本不能保证单例的唯一性。
– 说明：在多线程章节，会将懒汉式改造成线程安全的模式。