java基础总结05-面向对象

文章目录

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 封装

封装概述

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

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

5.2 继承

概念

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

特点

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

继承的好处和弊端

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

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

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

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

1. 通过使用super关键字去显示的调用父类的带参构造方法
2. 子类通过this去调用本类的其他构造方法,本类其他构造方法再通过super去手动调用父类的带参的构造方法

注意: this(…)super(…) 必须放在构造方法的第一行有效语句，并且二者不能共存

权限修饰符

在这里插入图片描述

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注解
- 用来检测当前的方法，是否是重写的方法，起到【校验】的作用

方法重写的注意事项

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

7. 重载

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

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

判断方法重载的依据

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

在这里插入图片描述

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();
    }
}

posted @ 2022-04-02 09:46 coderwcb 阅读(7) 评论(0) 编辑收藏举报

刷新页面返回顶部

登录后才能查看或发表评论，立即登录或者逛逛博客园首页

相关博文：

· Java基础知识面试题2021

· php 面向对象编程（class）之从入门到崩溃高级篇

· java基础（六）：面向对象

· Java — 面向对象

· 11.面向对象

java基础总结05-面向对象

文章目录

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 匿名内部类在开发中的使用

搜索

最新随笔

积分与排名

随笔分类 (3)

相册 (6)

阅读排行榜

评论排行榜

推荐排行榜

最新评论