JAVA 基础学习之面向对象 (2)

悠悠 2023-05-29 06:21 29阅读 0赞

# 面向对象进阶 #

## 1、概述： ##

本章的重点主要是面向对象的三大特征：继承、封装、多态。另外还包括抽象类、接口、内部类等概念。

## 2、继承 ##

###    2.1、好处： ###

继承让我们更加容易实现类的扩展。 比如，我们定义了人类，再定义Boy类就只需要扩展人类即可。实现了代码的重用，不用再重新发明轮子。extends 扩展的意思

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NDU2MDM0Mg_size_16_color_FFFFFF_t_70][]

## ##

### 2.2、instanceof 运算符 ###

instanceof是二元运算符，左边是对象，右边是类；当对象是右面类或子类所创建对象时，返回true；否则，返回false。

格式：

if(对象 instanceof 类){     执行的代码.... }

### 2.3、继承使用要点 ###

> 1、父类也称作超类、基类、派生类等等。
> 
> 2、java中类没有多继承，只有单继承。
> 
> 3、子类继承父类后，可以得到父类的全部属性和方法（除了父类的构造方法），但不可以直接访问父类的私有成员（属性和方法）。
> 
> 4、如果定义一个类时，没有调用extends，则它的父类是：java.lang.Object（默认）。
> 
> （如果定义一个类时，没有写继承别的父类时，则它的父类默认就是object类。）

### 2.4、方法的重写 ###

子类通过重写父类的方法，可以用自身的行为替换父类的行为。方法的重写是实现多态的必要条件。

2.4.1、方法的重写需要符合下面的三个要点：（要求）

> 1.    “==”  ：方法名 和 形参列表相同。
> 2.   “≤”     :   返回值类型和声明异常类型，子类小于或等于父类。
> 3.   “≥”     :   访问权限，子类 要大于或等于父类。（访问权限private为时？？？）

### 2.5、继承的优点和缺点 ###

优点：

> 1 提高了代码的复用性
> 
> 2 提高了代码的维护性
> 
> 3 建立了类与类之间的关系，继承是多态的前提。

继承的一个弊端：

> 1、打破了封装性。对于一些类，或者类中功能，是需要被继承，或者复写的。 这时如何解决问题呢？介绍一个关键字， final : 最终。
> 
> 2、在一定的程度上提高了类与类之间的耦合度

**总结：**继承可以更容易的实现类的扩展，java中类只有单继承。方法的重写实现多态的必要性条件，方法重写的前提是继承，记住方法重写的三要点

## 3、object 类基本特性 ##

Object类是所有Java类的根基类，也就意味着所有的Java对象都拥有Object类的属性和方法。如果在类的声明中未使用extends关键字指明其父类，则默认继承Object类。

### 3.1、tongString 方法 ###

Object类中定义有public String toString()方法，其返回值是 String 类型

### 3.2、==和equals方法 ###

<table style="width:500px;"> 
 <tbody> 
  <tr> 
   <td>方法</td> 
   <td>功能</td> 
  </tr> 
  <tr> 
   <td>==</td> 
   <td>代表比较双方是否相同，如果是基本类型则表示值相等，如果是引用类型则表示地址相等即是同一个对象</td> 
  </tr> 
  <tr> 
   <td>equals</td> 
   <td>Object 的 equals 方法默认就是比较两个对象的hashcode</td> 
  </tr> 
 </tbody> 
</table>

**4、super 关键字**

super是直接父类对象的引用。可以通过super来访问父类中被子类覆盖的方法或属性。

若是构造方法的第一行代码没有显式的调用super(...)或者this(...);那么Java默认都会调用super(),含义是调用父类的无参数构造方法。这里的super()可以省略。

### 4.1、继承树追溯 ###

·属性/方法查找顺序：(比如：查找变量h)

>       1. 查找当前类中有没有属性h
> 
>       2. 依次上溯每个父类，查看每个父类中是否有h，直到Object
> 
>       3. 如果没找到，则出现编译错误。
> 
>       4. 上面步骤，只要找到h变量，则这个过程终止。

## 5、封装 ##

###  5.1、概述 ###

封装是指隐藏对象的属性和实现细节，仅对外提供公共访问方式。

###   5.2、优点 ###

> 1、提高代码的安全性。
> 
> 2、提高代码的复用性。
> 
> 3. “高内聚”：封装细节，便于修改内部代码，提高可维护性。
> 
> 4. “低耦合”：简化外部调用，便于调用者使用，便于扩展和协作。

### 5.3、修饰符 ###

Java是使用“访问控制符”来控制哪些细节需要封装，哪些细节需要暴露的。 Java中4种“访问控制符”分别为private、default、protected、public，它们说明了面向对象的封装性，所以我们要利用它们尽可能的让访问权限降到最低，从而提高安全性。

![20191105085751190.png][]

> 1.   private 表示私有，只有自己类能访问。
> 2.   default  表示没有修饰符（默认），只用同一个包中的类能访问。
> 3.   protected  表示可以被同一个包的类以及其它包的子类访问。
> 4.   public  表示可以被该项目的所有包中的所有类访问

### 5.4、使用细节 ###

> 1.   一般使用private访问权限。
> 2.   提供相应的get/set方法来访问相关属性，这些方法通常是public修饰的，以提供对属性的赋值与读取操作(注意：boolean变量的get方法是is开头!)。
> 3.   一些只用于本类的辅助性方法可以用private修饰，希望其他类调用的方法用public修饰。

**总结**：封装是指隐藏对象的属性和实现细节，仅对外提供公共访问方式。

## 6、多态 ##

### 6.1、含义： ###

多态是同一个行为具有多个不同表现形式或形态的能力。

### 6.2、要点： ###

>       1. 多态是方法的多态，不是属性的多态(多态与属性无关)。
> 
>       2. 多态的存在要有3个必要条件：继承，方法重写，父类引用指向子类对象。
> 
>       3. 父类引用指向子类对象后，用该父类引用调用子类重写的方法，此时多态就出现了。

printer p=new 彩色打印机(); 
    printer p=new 黑白打印机();

### 6.3、优缺点 ###

多态的主要优势：是提高了代码的可扩展性，符合开闭原则。

多态的弊端：就是无法调用子类特有的功能。

### 6.4、对象转型 ###

父类引用指向子类对象，我们称这个过程为向上转型，属于自动类型转换。

向上转型后的父类引用变量只能调用它编译类型的方法，不能调用它运行时类型的方法。这时，我们就需要进行类型的强制转换，我们称之为向下转型!

## 7、final 关键字 ##

###   7.1、作用 ###

> 1.   被 final 修饰的类是一个最终类，不可以被继承。
> 2.   被 final 修饰的方法是一个最终方法，不可以被覆盖（重写）。
> 3.   被 final 修饰的变量是一个常量，只能赋值一次。

## 8、抽象方法和抽象类 ##

###   8.1、抽象方法 ###

被abstract修饰的方法，没有方法体，只有声明。定义的是一种“规范”，就是告诉子类必须要给抽象方法提供具体的实现。

### 8.2、抽象类 ###

被abstract修饰的类就是抽象类，通过abstract方法定义规范，然后要求子类必须定义具体实现。可以把抽象类看成一个模板，需要子类去实现。

/*抽象类*/
    abstract class abstr{
    //抽象方法abstract void show();
    }

8.2.1、要点

> 1、抽象类不能实例化，即不能用new来实例化抽象类。
> 
> 2、抽象类可以包含属性、方法、构造方法。但是构造方法不能用来new实例，只能用来被子类调用。
> 
> 3、抽象类只能用来被继承。
> 
> 4、抽象方法必须被子类实现。

总结：抽象方法没有方法体，只有声明；抽象类不能被实例化（不能代表没有构造函数）。抽象类只能用来被继承。

抽象方法必须被子类实现。

## 9、接口（interface） ##

### 9.1、概述： ###

java中的接口是类的蓝图。 它有静态常量和抽象方法。java中的接口是一种实现抽象的机制。 接口中只有抽象方法。接口用于在Java中实现抽象和多重继承。Java接口也表示IS-A关系。它不能像抽象类一样被实例化。从接口的实现者角度看，接口定义了可以向外部提供的服务。从接口的调用者角度看，接口定义了实现者能提供那些服务。接口和实现类不是父子关系，是实现规则的关系。

### 9.2、声明格式： ###

[访问修饰符]  interface 接口名   [extends  父接口1，父接口2…]  {常量定义；  方法定义；}

定义接口的详细说明：

> 1.   访问修饰符：只能是public或默认（default）。
> 2.   接口名：和类名采用相同命名机制。
> 3.   extends：接口可以多继承。
> 4.   常量：接口中的属性只能是常量，总是：public static final 修饰。不写也是。
> 5.   方法：接口中的方法只能是：public abstract。 省略的话，也是public abstract。

### 9.3、要点 ###

> 1.   普通类可以通过implement来实现接口中的规范。
> 2.   接口不能创建实例，但是可用于声明引用变量类型。
> 3.   JDK1.7之前，接口中只能包含静态常量、抽象方法，不能有普通属性、构造方法、普通方法。
> 4.   JDK1.8后，接口中包含普通的静态方法。
> 5.   一个类实现了接口，必须实现接口中所有的抽象方法。

示例：

public class Test21 {
        public static void main(String[] args) throws Exception {
        	Test impl=new TestImpl();
        	impl.show();//调用实现方法
        	Test.statics();//调用静态方法
    	}
    }
    interface Test{
    	abstract void show();//抽象方法
    	 static void statics() {//静态方法
    		System.out.println("我是静态方法");
    	 };
    }
    class TestImpl implements Test {
    	@Override
    	public void show() {
    		System.out.println("我是实现方法");
    	}
    }

结果：

![20191105090922384.png][]

## 10、内部类 ##

### 10.1、概念： ###

有些情况下，我们把一个类放在另一个类的内部定义，称为内部类(innerclasses)。

内部类可以使用public、default、protected 、private以及static修饰。而外部顶级类(我们以前接触的类)只能使用public和default修饰。

public class Testnb {
    	private int age=10;
    	String name;
    	public class Testnbl{
    		//内部类中可以声明与外部类同名的属性与方法
            private int age = 20;
    	}  
    }

### 10.2、作用 ###

> 1.   内部类提供了更好的封装。只能让外部类直接访问，不允许同一个包中的其他类直接访问。
> 2.   内部类可以直接访问外部类的私有属性，内部类被当成其外部类的成员。 但外部类不能直接访问内部类的内部属性。（外部类如果需要访问内部类的属性，必须创建对象）
> 3.   接口只是解决了多重继承的部分问题，而内部类使得多重继承的解决方案变得更加完整。

### 10.3、内部类的分类 ###

在Java中内部类主要分为成员内部类(非静态内部类、静态内部类)、匿名内部类、局部内部类。

**成员内部类(可以使用****private****、default、protected、public****任意进行修饰。** **类文件：外部类$内部类.class****)**

a、非静态内部类

> 1.   非静态内部类必须寄存在一个外部类对象里，因此，如果有一个非静态内部类对象那么一定存在对应的外部类对象。非静态内部类对象单独属于外部类的某个对象。
> 2.   非静态内部类可以直接访问外部类的成员，但是外部类不能直接访问内部类的成员。
> 3.   非静态内部类不能有静态方法、静态属性和静态初始化块。
> 4.   外部类的静态方法、静态代码块不能访问非静态内部类，包括不能使用非静态内部类定义变量、创建实例。
> 5.   访问要点：局部变量：变量名；内部类属性：this.变量名；外部类属性：外部类名.this.变量名。
> 6.   访问格式：

1. 外部类中定义内部类：

> new inner（）

2.外部类以外的地方使用非静态内部类：

> Outer.Inner  varname = **new** Outer().**new** Inner()。

b、静态内部类

定义方式

> **static**  **class**   ClassName \{ //类体\}

为什么静态内部类的实例方法不能直接访问外部类的实例方法？

静态内部类是外部类的类相关的，而不是外部类的对象相关的。也就是说，静态内部类对象不是寄生在外部类的实例中，而是寄生在外部类的类本身中。

静态内部类看做外部类的一个静态成员。 因此，外部类的方法中可以通过：“静态内部类.名字”的方式访问静态内部类的静态成员，通过 new 静态内部类()访问静态内部类的实例

c、匿名内部类

适合那种只需要使用一次的类。比如：键盘监听操作等等。

语法：

> **new**  父类构造器(实参类表) \\实现接口 () \{           //匿名内部类类体！\}

注意：

1. 匿名内部类没有访问修饰符。

2. 匿名内部类没有构造方法。因为它连名字都没有那又何来构造方法呢。

d、局部内部类

它是定义在方法内部的，作用域只限于本方法，称为局部内部类。

格式：

public class Test2 {
        public void show() {
            //作用域仅限于该方法
            class Inner {
                public void fun() {
                    System.out.println("helloworld");
                }
            }
            new Inner().fun();
        }
        public static void main(String[] args) {
            new Test2().show();
        }
    }

总结：内部类主要分为成员内部类（非静态内部类、静态内部类）、匿名内部类、局部内部类。

## 11、String 基础 ##

String类又称作不可变字符序列。

> String e = ""  ; // 空字符串String greeting = " Hello World ";

### 11.1、常量池 ###

常量池分为为三个：**全局字符串常量池、class文件常量池、运行时常量池**

### 11.2、String类常用的方法 ###

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NDU2MDM0Mg_size_16_color_FFFFFF_t_70 1][]

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NDU2MDM0Mg_size_16_color_FFFFFF_t_70]: https://img-blog.csdnimg.cn/20191105083642541.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NDU2MDM0Mg==,size_16,color_FFFFFF,t_70
[20191105085751190.png]: https://img-blog.csdnimg.cn/20191105085751190.png
[20191105090922384.png]: https://img-blog.csdnimg.cn/20191105090922384.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NDU2MDM0Mg_size_16_color_FFFFFF_t_70 1]: https://img-blog.csdnimg.cn/20191105091401283.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NDU2MDM0Mg==,size_16,color_FFFFFF,t_70