java基础总结05-面向对象

深碍√TFBOYSˉ_ 2022-08-31 02:30 187阅读 0赞

### 文章目录 ###

*   *  1. 类和对象的关系
     *  2. 成员变量和局部变量的区别
     *  3. 构造方法
     *   *  3.1 构造方法的格式和执行时机
         *  3.2 构造方法的作用
         *  3.3 构造方法的注意事项
     *  4. this关键字
     *  5. 面向对象三大特征(封装，继承，多态)
     *   *  5.1 封装
         *  5.2 继承
         *   *  权限修饰符
         *  5.3 多态
         *   *  5.3.1 多态中的成员访问特点
             *  5.3.2 多态的好处和弊端
             *  5.3.3 多态中的转型
             *  5.3.4 instanceof =>多态中转型存在的风险和解决方案
     *  6. 方法重写
     *  7. 重载
     *  8. static关键字
     *  9. 抽象类(abstract)
     *  10. final
     *  11.代码块
     *   *  11.1 局部代码块
         *  11.2 构造代码块
         *  11.3 静态代码块
         *  11.4 同步代码块
     *  12. 接口(interface)
     *   *  12.1 接口的特点
         *  12.2 类和接口的关系
         *  12.3 接口组成
         *   *  12.3.1 常量：public static final
             *  12.3.1 抽象方法：public abstract
             *  12.3.1 默认方法（Java8）：default
             *  12.3.1 静态方法（Java8）：static
             *  12.3.1 私有方法（Java9）：private或者private static
         *  代码演示
     *  13 内部类
     *   *  13.1 成员内部类
         *  静态成员内部类
         *  13.2 局部内部类
         *  13.3 匿名内部类
         *  13.4 匿名内部类在开发中的使用

## 1. 类和对象的关系 ##

\*\*面向对象和面向过程的思想对比 : \*\*

\*\*面向过程 ：\*\*是一种以过程为中心的编程思想，实现功能的每一步，都是自己实现的

\*\*面向对象 ：\*\*是一种以对象为中心的编程思想，通过指挥对象实现具体的功能

客观存在的事物皆为对象 ，所以我们也常常说万物皆对象。

*  类和对象的关系
    
     *  类：类是对现实生活中一类具有共同属性和行为的事物的抽象（模板）
     *  对象：是能够看得到摸的着的真实存在的实体
     *  简单理解：**类是对事物的一种描述，对象则为具体存在的事物**
    
    **类是对象的抽象（模板），而对象是类的具体实例**

类的组成是由属性和行为两部分组成

*  \*\*属性：\*\*在类中通过成员变量来体现（类中方法外的变量）
 *  \*\*行为（方法）：\*\*在类中通过成员方法来体现（和前面的方法相比去掉static关键字即可）

## 2. 成员变量和局部变量的区别 ##

*  \*\*类中位置不同：\*\*成员变量（类中方法外）局部变量（方法内部或方法声明上）
 *  \*\*内存中位置不同：\*\*成员变量（堆内存）局部变量（栈内存）
 *  \*\*生命周期不同：\*\*成员变量（随着对象的存在而存在，随着对象的消失而消失）局部变量（随着方法的调用而存在，醉着方法的调用完毕而消失）
 *  \*\*初始化值不同：\*\*成员变量（有默认初始化值）局部变量（没有默认初始化值，必须先定义，赋值才能使用）

## 3. 构造方法 ##

### 3.1 构造方法的格式和执行时机 ###

*  **格式注意 :**
    
    1.  方法名与类名相同，大小写也要一致
    2.  没有返回值类型，连void都没有
    3.  没有具体的返回值（不能由retrun带回结果数据）
 *  **执行时机 ：**
    
     *  创建对象的时候调用，每创建一次对象，就会执行一次构造方法
     *  不能手动调用构造方法

### 3.2 构造方法的作用 ###

*  用于给对象的数据（属性）进行初始化

### 3.3 构造方法的注意事项 ###

**构造方法的创建 :**

如果没有定义构造方法，系统将给出一个默认的无参数构造方法

如果定义了构造方法，系统将不再提供默认的构造方法

**推荐的使用方式 :**

无论是否使用，都手动书写无参数构造方法，和带参数构造方法

**实例：**

package com.itheima.constructor;
    
    public class Student { 
        private String name;
        private int age;
    
        // 1. 如果一个类中没有编写任何构造方法,
        public Student(){ }
    
        // 2. 如果手动编写了构造方法, 系统就不会再提供默认的无参数构造方法了
        public Student(String name, int age){ 
            // 用于给对象的数据（属性）进行初始化
            this.name = name;
            this.age = age;
            System.out.println("我是Student类的构造方法");
        }
    
        public void show(){ 
            System.out.println(name + "..." + age);
        }
    }

## 4. this关键字 ##

**概述 :** this修饰的变量用于指代成员变量，其主要作用是（区分局部变量和成员变量的重名问题）

*  方法的形参如果与成员变量同名，不带this修饰的变量指的是形参，而不是成员变量
 *  **注意 :** this代表当前调用方法的引用，哪个对象调用的方法，this就代表哪一个对象

## 5. 面向对象三大特征(封装，继承，多态) ##

### 5.1 封装 ###

1.  **封装概述**
    
    即隐藏对象的属性和实现细节，仅对外公开接口，控制在程序中属性的读和修改的访问级别；
2.  **封装原则**  
    将类的某些信息隐藏在类内部，不允许外部程序直接访问，而是通过该类提供的方法来实现对隐藏信息的操作和访问  
    成员变量private，提供对应的getXxx()/setXxx()方法
3.  **封装好处**  
    通过方法来控制成员变量的操作，提高了代码的安全性  
    把代码用方法进行封装，提高了代码的复用性

自己理解：用于解决特定的功能

### 5.2 继承 ###

**概念**

*  继承就是子类继承父类的特征和行为，可以使得子类具有父类的属性和方法，还可以在子类中重新定义，以及追加属性和方法

**特点**

*  父类又叫超类或基类，子类又叫派生类
 *  在Java类中, 所有的类都默认继承Object类
 *  在Java中,所有的类只能继承一个父类\*\*（单继承）\*\*
 *  Java中类支持多层继承（子父爷）

**继承的好处和弊端**

*  继承好处
    
     *  提高了代码的复用性(多个类相同的成员可以放到同一个类中)
     *  提高了代码的维护性(如果方法的代码需要修改，修改一处即可)
 *  继承弊端
    
     *  继承让类与类之间产生了关系，类的耦合性增强了，当父类发生变化时子类实现也不得不跟着变化，削弱了子类的独立性

**访问特点 ：子类中所有的构造方法默认都会访问父类中无参的构造方法**

子类会继承父类中的数据，可能还会使用父类的数据。所以，子类初始化之前，一定要先完成父类数据的初始化，原因在于，每一个子类构造方法的第一条语句默认都是：super()

**问题：如果父类中没有无参构造方法，只有带参构造方法，该怎么办呢？**

1. 通过使用super关键字去显示的调用父类的带参构造方法
    2. 子类通过this去调用本类的其他构造方法,本类其他构造方法再通过super去手动调用父类的带参的构造方法
    
    注意: this(…)super(…) 必须放在构造方法的第一行有效语句，并且二者不能共存

#### 权限修饰符 ####

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NDc5NzE4Mg_size_16_color_FFFFFF_t_70]

### 5.3 多态 ###

*  什么是多态
    
     同一个对象，在不同时刻表现出来的不同形态
 *  多态的前提
    
     *  要有继承或实现关系
     *  要有方法的重写
     *  要有父类引用指向子类对象

#### 5.3.1 多态中的成员访问特点 ####

*  成员访问特点
    
     *  成员变量
        
         编译看父类，运行看父类
     *  成员方法
        
         编译看父类，运行看子类

#### 5.3.2 多态的好处和弊端 ####

*  好处
    
     提高程序的扩展性。定义方法时候，使用父类型作为参数，在使用的时候，使用具体的子类型参与操作
 *  弊端
    
     不能使用子类的特有成员

#### 5.3.3 多态中的转型 ####

*  向上转型
    
     父类引用指向子类对象就是向上转型
 *  向下转型
    
     格式：子类型 对象名 = (子类型)父类引用;
    
     Zi z = (Zi) f;

#### 5.3.4 instanceof =>多态中转型存在的风险和解决方案 ####

如果被转的引用类型变量,对应的实际类型和目标类型不是同一种类型,那么在转换的时候就会出现ClassCastException

实例

// 判断a变量记录的类型, 是否是Dog
            if(a instanceof Dog){ 
                Dog dog = (Dog) a;
                dog.watchHome();
            }

通俗的理解：判断关键字左边的变量，是否是右边的类型，返回boolean类型结果

## 6. 方法重写 ##

*  1、方法重写概念
    
     *  **子类出现了和父类中一模一样的方法声明（方法名一样，参数列表也必须一样）**
     *  方法的重写，不能发生在同类中，只能发生在子类中。
     *  方法重写的权限：子类中的权限大于或等于父类的权限,（修饰符高低：private < 默认修饰符<protected < public）
     *  *特殊情况：子类不能重写父类被声明为private权限的方法*
 *  2、方法重写的应用场景
    
     *  当子类需要父类的功能，而功能主体子类有自己特有内容时，可以重写父类中的方法，这样，即沿袭了父类的功能，又定义了子类特有的内容
 *  3、Override注解
    
     *  用来检测当前的方法，是否是重写的方法，起到【校验】的作用

**方法重写的注意事项**

1.  私有方法不能被重写(父类私有成员子类是不能继承的)
2.  子类方法访问权限不能更低(public > 默认 > 私有)
3.  静态方法不能被重写,如果子类也有相同的方法,并不是重写的父类的方法

## 7. 重载 ##

**定义**  
方法重载：如果同一个类中包含了两个及两个以上方法名相同，方法参数的个数、顺序或者类型不同的方法，则称为方法的重载。

简单的说就是：方法重载就是方法名称重复，加载参数不同。

**判断方法重载的依据**

1.  同一个类中，方法名称一致
2.  方法参数的个数、类型或者顺序不一致；
3.  与返回值、访问修饰符无关。

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NDc5NzE4Mg_size_16_color_FFFFFF_t_70 1]

## 8. static关键字 ##

static 关键字是静态的意思,是Java中的一个修饰符,可以修饰成员方法,成员变量

*  被类的所有对象共享
    
    是我们判断是否使用静态关键字的条件
 *  随着类的加载而加载，优先于对象存在
    
    对象需要类被加载后，才能创建
 *  可以通过类名调用
    
    也可以通过对象名调用

**static关键字注意事项**

*  静态方法只能访问静态的成员
 *  非静态方法可以访问静态的成员，也可以访问非静态的成员
 *  静态方法中是没有this关键字

## 9. 抽象类(abstract) ##

对现实世界中某一种类型的多种事物的抽象描述

**抽象类的特点**

*  抽象类和抽象方法必须使用 abstract 关键字修饰
 *  抽象类中不一定有抽象方法，有抽象方法的类一定是抽象类
 *  抽象类不能实例化
 *  抽象类可以有构造方法
 *  抽象类的子类
    
     要么重写抽象类中的所有抽象方法
    
     要么是抽象类

对抽象类理解:

*  分析事物时, 发现了共性的内容,就出现向上抽取,但是如果父类 的方法功能与子类不同,那么这时就不抽取方法主体,这样抽取出来的方法 就是抽象方法

总结: 
        1. 将像的部分和相似的部分抽取到一个父类当中(共性内容向上抽取)
                ***抽象类,就是一个特殊父类***
        2. 抽象类和普通父类的区别在于, 抽象类可以定义抽象方法
        3. 当我们将共性的行为(方法) 抽取到父类之中后, 发现该行为在父类中描述不清了,
        但这个行为还是子类(强制重写)必须要做的行为,就可以定义为抽象方法
    
                举例:  
                     	猫类 :
                            eat() { 吃素)))><< };
                        狗类 :
                            eat() {吃肉};
                        动物类 :
                            eat(); //按理说这是父类,但是将共性的eat方法抽取到父类中后,发现该行为描述不清了,这个方法我到底是吃肉还是吃素,所以这里需要子类自己定义

## 10. final ##

*  fianl关键字的作用
    
     *  final代表最终的意思，可以修饰成员方法，成员变量，类
 *  final修饰类、方法、变量的效果
    
     *  fianl修饰类：该类不能被继承（不能有子类，但是可以有父类）
     *  final修饰方法：该方法不能被重写
     *  final修饰变量：表明该变量是一个常量，不能再次赋值
        
         *  变量是基本类型,不能改变的是值
         *  变量是引用类型,不能改变的是地址值,但地址里面的内容是可以改变的

## 11.代码块 ##

在Java中，使用 \{ \} 括起来的代码被称为代码块

### 11.1 局部代码块 ###

*  位置: 方法中定义
 *  作用: 限定变量的生命周期，及早释放，提高内存利用率
 *  示例代码
    
        public class Test { 
            public static void main(String[] args) { 
                // 局部代码块
                { 
                    int a = 10;
                    System.out.println(a);
                }
            }
        }

### 11.2 构造代码块 ###

*  位置: 类中方法外定义
 *  特点: 每次构造方法执行的时，都会执行该代码块中的代码，**并且在构造方法执行前执行**
 *  作用: 将多个构造方法中相同的代码，抽取到构造代码块中，提高代码的复用性
 *  示例代码
    
        class Student { 
        		// 构造代码块:
                { 
                    System.out.println("好好学习");
                }
            }

### 11.3 静态代码块 ###

*  位置: 类中方法外定义
 *  特点: 需要通过static关键字修饰，**随着类的加载而加载，并且只执行一次**
 *  作用: 在类加载的时候做一些数据初始化的操作
 *  示例代码
    
        class Person { 
            //静态代码块:
            static { 
                System.out.println("我是静态代码块, 我执行了");
            }
        }

### 11.4 同步代码块 ###

*  类中synchronized（）\{\}括起来的语句，多线程环境下互斥执行,后面会介绍

synchronized(obj)
    { 
        //需要被同步的代码块
    }

## 12. 接口(interface) ##

官方解释：Java接口是一系列方法的声明，是一些方法特征的集合，**一个接口只有方法的特征没有方法的实现，因此这些方法可以在不同的地方被不同的类实现，而这些实现可以具有不同的行为（功能）**。

*  接口就是一种公共的规范标准，只要符合规范标准，大家都可以通用。
 *  Java中接口存在的两个意义
    
    1.  用来定义规范
    2.  用来做功能的拓展

### 12.1 接口的特点 ###

*  接口用关键字interface修饰
    
        public interface 接口名 { }
 *  类实现接口用implements表示
    
        public class 类名 implements 接口名 { }
 *  接口不能实例化
    
     我们可以创建接口的实现类对象使用
 *  接口的子类
    
     要么重写接口中的所有抽象方法
    
     要么子类也是抽象类

### 12.2 类和接口的关系 ###

*  类与类的关系
    
     继承关系，只能单继承，但是可以多层继承
 *  类与接口的关系
    
     实现关系，可以单实现，也可以多实现，还可以在继承一个类的同时实现多个接口
 *  接口与接口的关系
    
     继承关系，可以单继承，也可以多继承

### 12.3 接口组成 ###

#### 12.3.1 常量：public static final ####

public static final int NUM = 10;
        // 简单写法
        int NUM2 = 20;

#### 12.3.1 抽象方法：public abstract ####

public abstract void show();
    
        // 简单写法
        void show2();

#### 12.3.1 默认方法（Java8）：default ####

*  格式
    
    public default 返回值类型 方法名(参数列表) \{ \}
 *  范例
    
        public default void show3() {  
        }
 *  注意事项
    
     *  默认方法不是抽象方法，所以**不强制被重写**。但是**可以被重写，重写的时候去掉default关键字**
     *  public可以省略，default不能省略
     *  如果实现了多个接口，多个接口中存在相同的方法声明，子类就必须对该方法进行重写

#### 12.3.1 静态方法（Java8）：static ####

*  格式
    
    public static 返回值类型 方法名(参数列表) \{ \}
 *  范例
    
        public static void show() { 
        }
 *  注意事项
    
     *  静态方法只能通过接口名调用，不能通过实现类名或者对象名调用
     *  public可以省略，static不能省略

#### 12.3.1 私有方法（Java9）：private或者private static ####

*  私有方法产生原因
    
    Java 9中新增了带方法体的私有方法，这其实在Java 8中就埋下了伏笔：Java 8允许在接口中定义带方法体的默认方法和静态方法。这样可能就会引发一个问题：当两个默认方法或者静态方法中包含一段相同的代码实现时，程序必然考虑将这段实现代码抽取成一个共性方法，而这个共性方法是不需要让别人使用的，因此用私有给隐藏起来，这就是Java 9增加私有方法的必然性
 *  定义格式
    
     *  格式1
        
        private 返回值类型 方法名(参数列表) \{ \}
     *  范例1
        
            private void show() {   
            }
     *  格式2
        
        private static 返回值类型 方法名(参数列表) \{ \}
     *  范例2
        
            private static void method() {   
            }
 *  注意事项
    
     *  默认方法可以调用私有的静态方法和非静态方法
     *  静态方法只能调用私有的静态方法

### 代码演示 ###

package com.edu1.test;
    
    // 接口
    public interface Inter { 
        public static final int NUM = 10;
    
        public abstract void show();
    
        // 简单写法
        void show2();
    
        int NUM2 = 20;
    
        //Java8 - 不必须生成
        public default void show3() { 
            System.out.println("默认方法");
        }
    
        //Java8
        public static void show4() { 
            System.out.println("静态方法");
        }
    
        //Java9 我这版本不足,就不演示
        //private void show5() { 
        // System.out.println("私有方法");
        //}
        //
        Java9
        //private void show6() { 
        // System.out.println("私有静态方法");
        //}
    }
    
    
    class InterImpl implements Inter { 
    
        @Override
        public void show() { 
            System.out.println(NUM);
        }
    
        @Override
        public void show2() { 
            System.out.println(NUM2);
        }
    
    }
    // 测试类
    class TestInterface { 
        public static void main(String[] args) { 
            System.out.println(Inter.NUM);
            System.out.println(Inter.NUM2);
            InterImpl interClass = new InterImpl();
            interClass.show3();
            Inter.show4();
        }
    
    }

## 13 内部类 ##

### 13.1 成员内部类 ###

*  成员内部类的定义位置
    
     *  在类中方法，跟成员变量是一个位置
 *  外界创建成员内部类格式
    
     *  格式：外部类名.内部类名 对象名 = 外部类对象.内部类对象;
     *  举例：Outer.Inner oi = new Outer().new Inner();
 *  私有成员内部类
    
     *  将一个类，设计为内部类的目的，大多数都是不想让外界去访问，所以内部类的定义应该私有化，私有化之后，再提供一个可以让外界调用的方法，方法内部创建内部类对象并调用。
     *  示例代码：
        
            class Outer { 
                private int num = 10;
                private class Inner { 
                    public void show() { 
                        System.out.println(num);
                    }
                }
                public void method() { 
                    Inner i = new Inner();
                    i.show();
                }
            }
            public class InnerDemo { 
                public static void main(String[] args) { 
            		//Outer.Inner oi = new Outer().new Inner();
            		//oi.show();
                    Outer o = new Outer();
                    o.method();
                }
            }
 *  ### 静态成员内部类 ###
    
     *  静态成员内部类访问格式：外部类名.内部类名 对象名 = new 外部类名.内部类名();
     *  静态成员内部类中的静态方法：外部类名.内部类名.方法名();
     *  示例代码
        
            class Outer { 
                static class Inner { 
                    public void show(){ 
                        System.out.println("inner..show");
                    }
            
                    public static void method(){ 
                        System.out.println("inner..method");
                    }
                }
            }
            
            public class Test3Innerclass { 
                /* 静态成员内部类演示 */
                public static void main(String[] args) { 
                    // 外部类名.内部类名 对象名 = new 外部类名.内部类名();
                    Outer.Inner oi = new Outer.Inner();
                    oi.show();
            
                    Outer.Inner.method();
                }
            }

### 13.2 局部内部类 ###

*  局部内部类定义位置
    
     *  局部内部类是在方法中定义的类
 *  局部内部类方式方式
    
     *  局部内部类，外界是无法直接使用，需要在方法内部创建对象并使用
     *  该类可以直接访问外部类的成员，也可以访问方法内的局部变量
 *  示例代码
    
        class Outer { 
            private int num = 10;
            public void method() { 
                int num2 = 20;
                class Inner { 
                    public void show() { 
                        System.out.println(num);
                        System.out.println(num2);
                    }
                }
                Inner i = new Inner();
                i.show();
            }
        }
        public class OuterDemo { 
            public static void main(String[] args) { 
                Outer o = new Outer();
                o.method();
            }
        }

### 13.3 匿名内部类 ###

*  匿名内部类的前提
    
     *  存在一个类或者接口，这里的类可以是具体类也可以是抽象类
 *  匿名内部类的格式
    
     *  格式：new 类名 ( ) \{ 重写方法 \} new 接口名 ( ) \{ 重写方法 \}
     *  举例：
        
            new Inter(){ 
                @Override
                public void method(){ }
            }
 *  匿名内部类的本质
    
     *  本质：是一个继承了该类或者实现了该接口的子类匿名对象
 *  匿名内部类的细节
    
     *  匿名内部类可以通过多态的形式接受
        
            Inter i = new Inter(){ 
              @Override
                public void method(){ 
                    
                }
            }
 *  匿名内部类直接调用方法
    
        interface Inter{ 
            void method();
        }
        
        class Test{ 
            public static void main(String[] args){ 
                new Inter(){ 
                    @Override
                    public void method(){ 
                        System.out.println("我是匿名内部类");
                    }
                }.method();	// 直接调用方法
            }
        }

### 13.4 匿名内部类在开发中的使用 ###

*  匿名内部类在开发中的使用
    
     *  当发现某个方法需要，接口或抽象类的子类对象，我们就可以传递一个匿名内部类过去，来简化传统的代码
 *  示例代码：
    
        /* 游泳接口 */
        interface Swimming { 
            void swim();
        }
        
        public class TestSwimming { 
            public static void main(String[] args) { 
                goSwimming(new Swimming() { 
                    @Override
                    public void swim() { 
                        System.out.println("铁汁, 我们去游泳吧");
                    }
                });
            }
        
            /** * 使用接口的方法 */
            public static void goSwimming(Swimming swimming){ 
                /* Swimming swim = new Swimming() { @Override public void swim() { System.out.println("铁汁, 我们去游泳吧"); } } */
                swimming.swim();
            }
        }

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NDc5NzE4Mg_size_16_color_FFFFFF_t_70]: /images/20220829/eee16cddc9c64dd1adeb5b7090db35bd.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NDc5NzE4Mg_size_16_color_FFFFFF_t_70 1]: /images/20220829/ec0e91a23cdb4a2bb523f10136ab521d.png