开发: C++知识库 Java知识库 JavaScript Python PHP知识库人工智能区块链大数据移动开发嵌入式开发工具数据结构与算法开发测试游戏开发网络协议系统运维
教程: HTML教程 CSS教程 JavaScript教程 Go语言教程 JQuery教程 VUE教程 VUE3教程 Bootstrap教程 SQL数据库教程 C语言教程 C++教程 Java教程 Python教程 Python3教程 C#教程
数码: 电脑笔记本显卡显示器固态硬盘硬盘耳机手机 iphone vivo oppo 小米华为单反装机图拉丁

-> Java知识库 -> Java核心技术之面向对象详细解读 -> 正文阅读

[Java知识库]Java核心技术之面向对象详细解读

文章目录

Java基础

Java基础

一. 类

属性

别名：成员变量、field、域、字段

属性与局部变量的异同：

同：

格式相同：数据类型变量名 = 变量值
先声明后使用
有其作用域

异：

属性直接定义在{}内
属性拥有权限修饰
属性有初始值
属性加载到堆空间，局部变量加载到栈空间

包装类

自动拆箱与自动装箱

Integer a = 2;	//自动装箱 调用了 Integer.valueof(2);
int b = a;		//自动拆箱 调用了 a.intValue();

String与Integer(Int)类型转换

String str = String.valueof(12.2f);//float-->>String
float f = Float.parseFloat(str);//String-->>float

注意：

当使用parseFloat时可能会出现NumberFormatException异常

缓存池

new Integer(123)与Integer.valueOf(123)的区别：

new Integer(123)会每次新建一个对象
Integer.valueOf(123)会使用缓存池中的对象


    Integer x = new Integer(123);
    Integer y = new Integer(123);
    System.out.println(x == y);    // false
    Integer z = Integer.valueOf(123);
    Integer k = Integer.valueOf(123);
    System.out.println(z == k);   // true

在JDK8中，Integer缓存池的大小默认为-128~127

二. 关键字

static

静态属性

静态变量：又称类变量，也就是说这个变量属于类的，类的所有实例都共享一份数据，可以直接通过类名来访问。静态变量在内存中只存在一份，存在方法区的静态域中。
实例变量：每创建一个实例就会产生一个实例变量，它与该实例同生共死。

public class A {

    private int x;         // 实例变量
    private static int y;  // 静态变量

    public static void main(String[] args) {
        // int x = A.x;  // Non-static field 'x' cannot be referenced from a static context
        A a = new A();
        int x = a.x;
        int y = A.y;
    }
}

静态方法
- 随着类的加载而加载，不依赖任何对象，所以静态方法必须有实现，并且只能调用静态属性。
```
public abstract class A {
    public static void func1(){
    }
    // public abstract static void func2();  // Illegal combination of modifiers: 'abstract' and 'static'
}
```
注意点
- 在静态方法内，不能使用this关键字，super关键字(生命周期)

静态代码块

静态代码块在类初始化的时候运行一次。

public class A {
    static {
        System.out.println("123");
    }

    public static void main(String[] args) {
        A a1 = new A();
        A a2 = new A();
    }
}

静态内部类
静态导包

在使用静态变量和方法时不用再指明类名，简化代码，降低可读性。
```
import static com.xxx.ClassName.*
```
初始化顺序

由父及子，静态先行

final

可以用来修饰：类、方法、变量

修饰类

此类不能被继承
修饰方法

此类不能被重写
修饰变量

修饰变量时，此时“变量”就是一个常量
static final修饰属性：全局变量

三. Object类

概述

Object类是所有类的父类

equals方法

equals与==比较
- 对于基本类型，==判断两个值是否相等，基本类型没有equals()方法
- 对于引用类型，==判断两个变量是否引用同一个对象，而equals()判断引用的对象是否等价
```
Integer x = new Integer(1);
Integer y = new Integer(1);
System.out.println(x.equals(y)); // true
System.out.println(x == y);      // false
```
开发中实现快捷键

equ，之后可以手动重写

toString方法

Object类中toString()的定义

public String toString() {
    return
        getClass().getName() + "@" + Integer.toHexString(hashCode()); 
}

开发中快捷键：tos

四. 继承

访问权限

java中共有三个访问权限修饰符：private、default(一般省却)、protected、public

权限	类内	同包	不同包子类	不同包非子类
private	√	×	×	×
default	√	√	×	×
protected	√	√	√	×
public	√	√	√	√

super

访问父类的构造函数：可以用super()函数访问父类的构造函数，从而委托父类完成一些初始化工作。子类一定会调用父类的构造函数来完成初始化工作，一般调用父类的默认构造函数，如果子类需要调用父类其它构造函数，那么就可以使用super()函数
访问父类的成员：如果子类重写了父类的某个方法，可以通过super关键字来引用父类的方法实现。
同名属性同上

重写与重载

重写(Override)

子类继承父类以后，可以对父类中同名同参数的方法进行覆盖操作。

三个限制：
- 子类方法的访问权限必须大于父类方法
- 子类方法的返回类型是父类方法返回类型或其子类
- 子类方法抛出的异常类型必须是父类抛出的异常类型或其子类

重载(Overload)

存在于同一个类中，指一个方法与已经存在的方法名称上相同，单数参数类型、个数、顺序至少有一个不同。

注意：返回值不同，其它都相同不算重载。

class OverloadingExample {
    public void show(int x) {
        System.out.println(x);
    }

    public void show(int x, String y) {
        System.out.println(x + " " + y);
    }
}

public static void main(String[] args) {
    OverloadingExample example = new OverloadingExample();
    example.show(1);
    example.show(1, "2");
}

多态

理解：一个事物的多种形态
何谓多态性：父类的引用指向子类的对象（或子类的对象赋给父类的引用）
```
Person p = new Man();
Object obj = new Date();
```
多态性的使用：编译看左运行看右

前提：类的继承关系与方法的重写
注意点：只适用于方法，不适用于属性
关于向上转型与向下转型

向上转型：多态

向下转型：强制类型转换
- 注意点：使用强制类型转换时，可能出现ClassCastException
- 为了避免异常可以使用instanceof
```
a instanceof A:判断对象a是否是类A的实例。如果是，返回true；如果不是，返回false
```

抽象类与接口

抽象类
- 修饰类
  
  此类不能实例化。
  
  抽象类中一定有构造器，便于让子类实例化调用。
  
  开发中，都会提供抽象类的子类，让子类实例化，完成相应的操作。
  
  抽象类使用的前提：继承性。
- 修饰方法
  
  抽象方法只有方法的声明，没有方法体。
  
  包含抽象方法的类一定是抽象类。反之不成立。
  
  若子类重写了父类所有的抽象方法后，此子类可实例化。
  
  若子类未能重写父类所有的抽象方法，此子类也是抽象类。
- 注意点
  1. abstract不能用来修饰：属性、构造器等结构
  2. abstract不能用来修饰私有方法、静态方法、final方法、final的类。
接口

接口是抽象类的延伸，在 Java 8 之前，它可以看成是一个完全抽象的类，也就是说它不能有任何的方法实现。

从 Java 8 开始，接口也可以拥有默认的方法实现，这是因为不支持默认方法的接口的维护成本太高了。在 Java 8 之前，如果一个接口想要添加新的方法，那么要修改所有实现了该接口的类，让它们都实现新增的方法。

接口的成员（字段 + 方法）默认都是 public 的，并且不允许定义为 private 或者 protected。从 Java 9 开始，允许将方法定义为 private，这样就能定义某些复用的代码又不会把方法暴露出去。

接口的字段默认都是 static 和 final 的。

五. 异常

异常的分类

* 一、异常的体系结构
* java.lang.Throwable
*      |----java.lang.Error:一般不编写针对性的对吗进行处理
*      |----java.lang.Exception:可以进行异常处理
*          |----编译时异常(checked)
*              |----IOException
*                  |----FileNotFoundException
*              |----ClassNotFoundException
*          |----运行时异常(unchecked, RuntimeException)
*              |----NullPointerException
*              |----ArrayIndexOutOfBoundsException
*              |----ClassCastException
*              |----NumberFormatException
*              |----InputMismatchException
*              |----ArithmeticException

Exception中分为两种异常：

checked(受检异常)：需要用 try…catch… 语句捕获并进行处理，并且可以从异常中恢复。

unchecked(非受检异常)：是程序运行时错误，例如除 0 会引发 Arithmetic Exception，此时程序崩溃并且无法恢复。

异常的处理
- try-catch-finally
```
try{
     //可能出现异常的代码
}catch(异常类型1 变量名1){
     //处理异常的方式1
}catch(异常类型2 变量名2){
     //处理异常的方式2
}
...
finally{
     //一定会执行的代码
}
```
  说明：
  1. finally是可选的。
  2. 使用try将可能出现异常代码包装起来，在执行过程中，一旦出现异常，就会生成一个对应异常类的对象，根据此对象的类型，去catch中进行匹配
  3. 一旦try中的异常对象匹配到某一个catch时,就进入catch中进行异常处理。一旦处理完成，就跳出当前的try-catch结构（在没有finally情况下）。继续执行其后的代码。
  4. catch中的异常类型如果没有子父类关系，则谁声明在上，谁声明在下无所谓。
    
    catch中的异常类型如果满足子父类关系，则要求子类一定声明在父类的上面。否则，报错.
  5. 常用的异常处理的方式：①String getMessage() ②printStackTrace()。
  6. 在try结构中声明的变量，再出了try结构以后，就不能再被调用
  7. try-catch-finally结构可以嵌套
- throws
```
“throws + 异常类型”写在方法的声明处。指明此方法执行时，可能会抛出的异常类型
*     一旦当方法执行时，出现异常，仍会在异常代码出生成一个异常类的对象满足throws后
*     异常类型时，就会抛出。异常代码后续的代码，就不再执行
```
- 对比两种处理方式
  
  try-catch-finally：真正的将异常给处理掉了。
  
  throws的方式只是将异常抛给了方法的调用者。并没有真正的将异常处理掉。
手动抛出异常对象
- throw

自定义异常类

如何自定义异常类

继承于现有的异常结构：RuntimeException、Exception
提供全局常量serialVersionUID
提供重载构造器

public class MyException extends Exception{
   static final long serialVersionUID = -7034897190745766939L;


   public MyException(String msg){
       super(msg);
   }
}

class Student{
    private int id;

    public void regist(int id) throws MyException {
        if(id > 0){
            this.id = id;
        }
        else{
            throw new MyException("不能输入负数");
        }
    }
}