⑨Java面向对象之关键字与其它

OwnStudy

已于 2022-09-28 16:01:58 修改

阅读量175

点赞数

分类专栏： Java学习文章标签： java 开发语言

于 2022-09-28 15:40:10 首次发布

本文链接：https://blog.csdn.net/own996/article/details/126994812

版权

Java学习专栏收录该内容

10 篇文章 0 订阅

订阅专栏

Java面向对象之关键字与其它

前言

本篇是学习Java面向对象过程中所用到的一些关键字和包装类等的记录。

一、关键字：Abstract

1.1 Abstract

用abstract关键字来修饰一个类，这个类叫做抽象类。
用abstract来修饰一个方法，该方法叫做抽象方法。
- 抽象方法：只有方法的声明，没有方法的实现。以分号结束：
- 比如：public abstract void talk();
含有抽象方法的类必须被声明为抽象类。
抽象类不能被实例化。抽象类是用来被继承的，抽象类的子类必须重写父类的抽象方法，并提供方法体。若没有重写全部的抽象方法，仍为抽象类。
不能用abstract修饰变量、代码块、构造器；
不能用abstract修饰私有方法、静态方法、final的方法、final的类。

小知识点：

/创建了一匿名子类的对象：p
Person p = new Person(){
	@Override
	public void eat() {
		System.out.println("吃东西");
	}
	@Override
	public void breath() {
		System.out.println("好好呼吸");
	}
};
method1(p);
System.out.println("********************");
//创建匿名子类的匿名对象
method1(new Person(){
	@Override
	public void eat() {
		System.out.println("吃好吃东西");
	}
	@Override
	public void breath() {
		System.out.println("好好呼吸新鲜空气");
	}
});

1.2 多态的应用：模板方法设计模式(TemplateMethod)

抽象类体现的就是一种模板模式的设计，抽象类作为多个子类的通用模板，子类在抽象类的基础上进行扩展、改造，但子类总体上会保留抽象类的行为方式。
解决的问题：
- 当功能内部一部分实现是确定的，一部分实现是不确定的。这时可以把不确定的部分暴露出去，让子类去实现。
- 换句话说，在软件开发中实现一个算法时，整体步骤很固定、通用，这些步骤已经在父类中写好了。但是某些部分易变，易变部分可以抽象出来，供不同子类实现。这就是一种模板模式。

二、关键字：interface

2.1 interface(接口)（可以有多个接口）

一方面，有时必须从几个类中派生出一个子类，继承它们所有的属性和方法。但是，Java不支持多重继承。有了接口，就可以得到多重继承的效果。
另一方面，有时必须从几个类中抽取出一些共同的行为特征，而它们之间又没有is-a的关系，仅仅是具有相同的行为特征而已。例如：鼠标、键盘、打印机、扫描仪、摄像头、充电器、MP3机、手机、数码相机、移动硬盘等都支持USB连接。
接口就是规范，定义的是一组规则，体现了现实世界中“如果你是/要…则必须能…”的思想。继承是一个"是不是"的关系，而接口实现则是 "能不能"的关系。
接口的本质是契约，标准，规范，就像我们的法律一样。制定好后大家都要遵守。
接口(interface)是抽象方法和常量值定义的集合。
接口的特点：
（1）用interface来定义。
（2）接口中的所有成员变量都默认是由public static final修饰的。
（3）接口中的所有抽象方法都默认是由public abstract修饰的。
（4）接口中没有构造器。
（5）接口采用多继承机制。

接口定义举例：

public interface Runner {
      int ID = 1;
      void start();
      public void run();
      void stop();
  } //上下相等
public interface Runner {
      public static final int ID = 1;
      public abstract void start();
      public abstract void run();
      public abstract void stop();
  }

定义Java类的语法格式：先写extends，后写implements
例：class SubClass extends SuperClass implements InterfaceA{ }
一个类可以实现多个接口，接口也可以继承其它接口（可以多继承）。
实现接口的类中必须提供接口中所有方法的具体实现内容，方可实例化。否则，仍为抽象类。
接口的主要用途就是被实现类实现。（面向接口编程）
与继承关系类似，接口与实现类之间存在多态性
接口和类是并列关系，或者可以理解为一种特殊的类。从本质上讲，接口是一种特殊的抽象类，这种抽象类中只包含常量和方法的定义(JDK7.0及之前)，而没有变量和方法的实现。

2.2 Java 8中关于接口的改进

Java 8中，你可以为接口添加静态方法和默认方法。从技术角度来说，这是完全合法的，只是它看起来违反了接口作为一个抽象定义的理念。
静态方法：使用 static 关键字修饰。可以通过接口直接调用静态方法，并执行其方法体。我们经常在相互一起使用的类中使用静态方法。你可以在标准库中找到像Collection/Collections或者Path/Paths这样成对的接口和类。
默认方法：默认方法使用 default 关键字修饰。可以通过实现类对象来调用。我们在已有的接口中提供新方法的同时，还保持了与旧版本代码的兼容性。
比如：java 8 API中对Collection、List、Comparator等接口提供了丰富的默认方法。
（注意）接口中的默认方法
- 若一个接口中定义了一个默认方法，而另外一个接口中也定义了一个同名同参数的方法（不管此方法是否是默认方法），在实现类同时实现了这两个接口时，会出现：接口冲突。
  - 解决办法：实现类必须覆盖接口中同名同参数的方法，来解决冲突。
- 若一个接口中定义了一个默认方法，而父类中也定义了一个同名同参数的非抽象方法，则不会出现冲突问题。因为此时遵守：类优先原则。接口中具有相同名称和参数的默认方法会被忽略。

2.3 接口的应用：代理模式(Proxy)、工厂设计模式

代理模式是Java开发中使用较多的一种设计模式。代理设计就是为其他对象提供一种代理以控制对这个对象的访问。
应用场景：
- 安全代理：屏蔽对真实角色的直接访问
- 远程代理：通过代理类处理远程方法调用（RMI）
- 延迟加载：先加载轻量级的代理对象，真正需要再加载真实对象
  - 比如你要开发一个大文档查看软件，大文档中有大的图片，有可能一个图片有
    100MB，在打开文件时，不可能将所有的图片都显示出来，这样就可以使用代理
    模式，当需要查看图片时，用proxy来进行大图片的打开
分类
- 静态代理（静态定义代理类）
- 动态代理（动态生成代理类）
  - JDK自带的动态代理，需要反射等知识

2.4 接口和抽象类对比

在开发中，常看到一个类不是去继承一个已经实现好的类，而是要么继承抽象类，要么实现接口。

2.5 代码

public class InterfaceTest {

}

class Plane {

}

//接口：抽象方法和常量的集合
interface Flyable {

}


//面试题一
interface A {
    int x = 0;
}
class B {
    int x = 1;
}
class C extends B implements A {
    public void pX() {
//        System.out.println(x);  //报错，父类和接口中变量重名，变量调用不明确
        System.out.println(super.x);  //调用父类变量
        System.out.println(A.x);  //接口中的x为全局静态变量（常量）
    }
    public static void main(String[] args) {
        new C().pX();
    }
}


//面试题二
interface Playable {
    void play();
}
interface Bounceable {
    void play();
}
interface Rollable extends Playable, Bounceable {
    Ball ball = new Ball("PingPang");  //接口中：常量，抽象方法，静态final对象
}

class Ball implements Rollable {
    private String name;
    public String getName() {
        return name;
    }
    public Ball(String name) {
        this.name = name;
    }
    public void play() {  //即认为为Playable接口中方法的实现，也可以认为是对Bounceable接口的实现
//        ball = new Ball("Football"); //报错，对象为final
        System.out.println(ball.getName());
    }
}

三、关键字：super & this

3.1 super

在Java类中使用super来调用父类中的指定操作：
- super可用于访问父类中定义的属性
- super可用于调用父类中定义的成员方法
- super可用于在子类构造器中调用父类的构造器
注意
- 尤其当子父类出现同名成员时，可以用super表明调用的是父类中的成员
- super的追溯不仅限于直接父类，还可以是间接父类
- super和this的用法相像，this代表本类对象的引用，super代表父类的内存空间的标识
super调用父类构造器
- 子类中所有的构造器默认都会访问父类中空参数的构造器
- 当父类中没有空参数的构造器时，子类的构造器必须通过this(参数列表)或者super(参数列表)语句指定调用本类或者父类中相应的构造器
  同时，只能”二选一”，且必须放在构造器的首行
- 如果子类构造器中既未显式调用父类或本类的构造器，且父类中又没有无参的构造器，则编译出错

3.2 this

在Java中，this关键字比较难理解，它的作用和其词义很接近
- 它在方法内部使用，即这个方法所属对象的引用；
- 它在构造器内部使用，表示该构造器正在初始化的对象。
this 可以调用类的属性、方法和构造器
什么时候使用this关键字呢？
- 当在方法内需要用到调用该方法的对象时，就用this。
- 具体的：我们可以用this来区分属性和局部变量。
  - 比如：this.name = name;
注意：
- 可以在类的构造器中使用"this(形参列表)"的方式，调用本类中重载的其他的构造器！
- 明确：构造器中不能通过"this(形参列表)"的方式调用自身构造器
- 如果一个类中声明了n个构造器，则最多有 n - 1个构造器中使用了"this(形参列表)"
- "this(形参列表)"必须声明在类的构造器的首行！
- 在类的一个构造器中，最多只能声明一个"this(形参列表)"

3.3 super & this的区别

在这里插入图片描述

四、关键字：package & import

4.1 package

package语句作为Java源文件的第一条语句，指明该文件中定义的类所在的包。(若缺省该语句，则指定为无名包)。
它的格式为：package 顶层包名.子包名 ;
包对应于文件系统的目录，package语句中，用 “.” 来指明包(目录)的层次；
包通常用小写单词标识。通常使用所在公司域名的倒置；
包帮助管理大型软件系统：将功能相近的类划分到同一个包中。比如：MVC的设计模式
包可以包含类和子包，划分项目层次，便于管理
解决类命名冲突的问题
控制访问权限

4.2 import

为使用定义在不同包中的Java类，需用import语句来引入指定包层次下所需要的类或全部类(.*)。import语句告诉编译器到哪里去寻找类。
语法格式：import 包名.类名;
注意：
1. 在源文件中使用import显式的导入指定包下的类或接口
2. 声明在包的声明和类的声明之间。
3. 如果需要导入多个类或接口，那么就并列显式多个import语句即可
4. 举例：可以使用java.util.的方式（不包含子包），一次性导入util包下所有的类或接口。
5. 如果导入的类或接口是java.lang包下的，或者是当前包下的，则可以省略此import语句。*
6. 如果在代码中使用不同包下的同名的类。那么就需要使用类的全类名的方式指明调用的是哪个类。
7. 如果已经导入java.a包下的类。那么如果需要使用a包的子包下的类的话，仍然需要导入。
8. import static组合的使用：调用指定类或接口下的静态的属性或方法

五、关键字：static & final

5.1 static

static: 可以修饰属性、方法、代码块、内部类
修饰属性：按是否使用static修饰，又分为：静态属性（静态变量） vs 非静态属性（实例变量）
- 实例变量：我们创建了类的多个对象，每个对象都独立的拥有一套类中的非静态属性。当修改其中一个对象中的非静态属性时，不会导致其他对象中同样的属性值的修改。
- 静态变量：我们创建了类的多个对象，多个对象共享同一个静态变量。当通过某一个对象修改静态变量时，会导致其他对象调用此静态变量时，是修改过了的。
- static修饰属性的其他说明：
  - 静态变量随着类的加载而加载。可以通过"类.静态变量"的方式进行调用
  - 静态变量的加载要早于对象的创建。
  - 由于类只会加载一次，则静态变量在内存中也只会存在一份：存在方法区的静态域中。
  - 静态属性举例：System.out; Math.PI;
- 修饰方法：静态方法
  - 随着类的加载而加载，可以通过"类.静态方法"的方式进行调用
  - 静态方法中，只能调用静态的方法或属性
  - 非静态方法中，既可以调用非静态的方法或属性，也可以调用静态的方法或属性
- static注意点：
  - 在静态的方法内，不能使用this、super关键字
  - 关于静态属性和静态方法的使用，通过其生命周期去理解
- 如何确定属性或方法是否需要使用static
  - 属性是可以被多个对象所共享的，不会随着对象的不同而不同的
  - 类中的常量也常常声明为static
  - 操作静态属性的方法，通常设置为static的
  - 工具类中的方法，习惯上声明为static的。比如：Math、Arrays、Collections

5.2 final

关键字：final（最终的）
- 在Java中声明类、变量和方法时，可使用关键字final来修饰,表示“最终的”。
  - final标记的类不能被继承。提高安全性，提高程序的可读性。
    - String类、System类、StringBuffer类
  - final标记的方法不能被子类重写。
    - 比如：Object类中的getClass()。
  - final标记的变量(成员变量或局部变量)即称为常量。名称大写，且只能被赋值一次。
    - final标记的成员变量必须在声明时或在每个构造器中或代码块中显式赋值，然后才能使用。
    - final double MY_PI = 3.14
  - static final：全局常量

六、其它（Object类、==&equals、单例模式、包装类）

6.1 Object类的使用

Object类的使用
- Object类是所有Java类的根父类
- 如果在类的声明中未使用extends关键字指明其父类，则默认父类为java.lang.Object类
- Object类中的功能(属性、方法)就具有通用性。
  - 属性：无
  - 方法：equals() / toString() / getClass() （接口） /hashCode() （集合中） / clone() / finalize() （垃圾回收）（线程中）wait() 、 notify()、notifyAll()
Object类中toString()使用
1. 当我们输出一个对象的引用时，实际上就是调用当前对象的toString()
2. Object类中toString()的定义：
  public String toString() {
  return getClass().getName() + “@” + Integer.toHexString(hashCode());
  }
3. 像String、Date、File、包装类等都重写了Object类中的toString()方法。使得在调用对象的toString()时，返回"实体内容"信息
4. 自定义类也可以重写toString()方法，当调用此方法时，返回对象的"实体内容"

6.2 ==&equals

==：运算符
- 可以使用在基本数据类型变量和引用数据类型变量中
- 如果比较的是基本数据类型变量：比较两个变量保存的数据是否相等。（不一定类型要相同）
  如果比较的是引用数据类型变量：比较两个对象的地址值是否相同。即两个引用是否指向同一个对象实体
- 补充： == 符号使用时，必须保证符号左右两边的变量类型一致(能统一为同一个数据类型，否则会编译出错)（比如Boolean和其他基本数据类型）。
equals()：方法
- 是一个方法，而非运算符
- 只能适用于引用数据类型
- Object类中equals()的定义：
  public boolean equals(Object obj) {
  return (this == obj);
  }
- 说明：Object类中定义的equals()和==的作用是相同的：比较两个对象的地址值是否相同。即两个引用是否指向同一个对象实体
- 像String、Date、File、包装类等都重写了Object类中的equals()方法。
  重写以后，比较的不是两个引用的地址是否相同，而是比较两个对象的"实体内容"是否相同。
- 通常情况下，我们自定义的类如果使用equals()的话，也通常是比较两个对象的"实体内容"是否相同。那么，我们就需要对Object类中的equals()进行重写。
- 重写的原则：比较两个对象的实体内容是否相同。
  - 对称性：如果x.equals(y)返回是“true”，那么y.equals(x)也应该返回是“true”。
  - 自反性：x.equals(x)必须返回是“true”。
  - 传递性：如果x.equals(y)返回是“true”，而且y.equals(z)返回是“true”，那么z.equals(x)也应该返回是“true”。
  - 一致性：如果x.equals(y)返回是“true”，只要x和y内容一直不变，不管你重复x.equals(y)多少次，返回都是“true”。
  - 任何情况下，x.equals(null)，永远返回是“false”；x.equals(和x不同类型的对象)永远返回是“false”。
面试题：==和equals的区别（*****）
1、 == 既可以比较基本类型也可以比较引用类型。对于基本类型就是比较值，对于引用类型就是比较内存地址
2、 equals的话，它是属于java.lang.Object类里面的方法，如果该方法没有被重写过默认也是==;
我们可以看到String等类的equals方法是被重写过的，而且String类在日常开发中用的比较多，久而久之，形成了equals是比较值的错误观点。
3、具体要看自定义类里有没有重写Object的equals方法来判断。
4、通常情况下，重写equals方法，会比较类中的相应属性是否都相等。

6.3 单例设计模式

设计模式是在大量的实践中总结和理论化之后优选的代码结构、编程风格、以及解决问题的思考方式。
单例设计模式是采取一定的方法保证在整个的软件系统中，对某个类只能存在一个对象实例，并且该类只提供一个取得其对象实例的方法。

单例模式实现（如下代码）

饿汉式 vs 懒汉式

/**
 * 单例模式(饿汉式)
 */
class Bank {
    //1.私有化构造器
    private Bank() {

    }

    //2.内部创建类的静态对象(在类被加载后，只存在一个静态对象（单例）)
    private static Bank instance = new Bank();

    //3.提供静态的公共的方法返回类的对象
    public static Bank getInstance() {
        return instance;
    }

}

/**
 * 单例模式（懒汉式）
 */
class Order {
    //1.私有化构造器
    private Order() {

    }

    //2.内部创建空的静态对象(在类被加载后，只存在一个静态对象（单例）)
    private static Order instance = null;

    //3.提供静态的公共的方法返回类的对象
    public static Order getInstance() {
        if(instance == null){
            instance = new Order();
        }
        return instance;
    }

}

区分饿汉式和懒汉式
- 饿汉式：
  - 坏处：对象加载时间过长
  - 好处：饿汉式是线程安全的
- 懒汉式：
  - （目前的写法）坏处：线程不安全–>后面在线程中可修改为线程安全
  - 好处：延迟对象的创建
单例(Singleton)设计模式–>应用场景
- 网站的计数器，一般也是单例模式实现，否则难以同步。
- 应用程序的日志应用，一般都使用单例模式实现，这一般是由于共享的日志文件一直处于打开状态，因为只能有一个实例去操作，否则内容不好追加。
- 数据库连接池的设计一般也是采用单例模式，因为数据库连接是一种数据库资源。
- 项目中，读取配置文件的类，一般也只有一个对象。没有必要每次使用配置文件数据，都生成一个对象去读取。
- Application 也是单例的典型应用
- Windows的Task Manager (任务管理器)就是很典型的单例模式
- Windows的Recycle Bin (回收站)也是典型的单例应用。在整个系统运行过程中，回收站一直维护着仅有的一个实例。

6.4 包装类（Wrapper）

包装类（Wrapper）的使用
- 针对八种基本数据类型定义相应的引用类型—包装类（封装类）(数值型的包装类的父类为Number)
- 有了类的特点，就可以调用类中的方法，Java才是真正的面向对象
基本数据类型、包装类与String类间的装换（掌握）
- 基本数据类型–>包装类 (装箱)
  - 通过包装类的构造器实现：
    int i = 500; Integer t = new Integer(i);
  - 还可以通过字符串参数构造包装类对象：
    Float f = new Float(“4.56”);
    Long l = new Long(“asdf”); //NumberFormatException
- 包装类–>基本数据类型（拆箱）
  - 调用包装类的.xxxValue()方法：
    boolean b = bObj.booleanValue();
- JDK1.5之后，支持自动装箱，自动拆箱。但类型必须匹配。
- 基本数据类型(或包装类)–>String类
  - 调用字符串重载的valueOf()方法：
    String fstr = String.valueOf(2.34f);
  - 更直接的方式：
    String intStr = 5 + “”
- String类–>基本数据类型（或包装类）
  - 通过包装类的构造器实现：
    int i = new Integer(“12”);
  - 通过包装类的parseXxx(String s)静态方法：
    Float f = Float.parseFloat(“12.1”);