面向对象相关知识点（内附举例）

最新推荐文章于 2024-07-13 13:55:40 发布

mmongin

最新推荐文章于 2024-07-13 13:55:40 发布

阅读量281

点赞数

分类专栏： Java 文章标签： java 编程语言封装多态抽象类

本文链接：https://blog.csdn.net/weixin_45790634/article/details/106732715

版权

Java 专栏收录该内容

2 篇文章 0 订阅

订阅专栏

面向对象相关知识点

知识点

知识点

类

对于一个具体的对象而言，比如一部 iPhone 6，世上还有许多跟这部手机有着同样属性或行为的对象，我们为了方便将它们归类起来，提取出他们相同的属性和行为，而我们把归类起来的这个抽象的概念，称之为类。

类是封装对象的属性和行为的载体，反过来说具有相同属性和行为的一类实体被称为类。

类是相同或相似对象的一种抽象，是对象的一个模板，它描述一类对象的行为和状态。
类是具有相同属性和方法（行为）的对象的集合

属性是对象具有的特征。每个对象的每个属性都拥有特定值。对象是一个具体并且确定的事物，正是对象属性的值来区分不同的对象，比如我们可以通过一个人的外貌特征区分他。

那什么是对象的行为呢？在计算机中我们通过方法去实现对象的行为，而对象的方法便是对象所具有的操作，比如人会走路、会哭泣、会学习等等都是人的行为，也就是人的方法。

类和对象之间有什么关系吗？在上面的讲解中大家应该有些了解了。类就是对象的抽象（或者模板），对象就是类的具体（或者实例）。比如手机是一个抽象的概念，它代表着类。而一部 iPhone 6 便是手机具象化处理的实体，也就是一个对象。

那我们如何在计算机中定义一个类，如何实现一个类呢？

Java 是面向对象的语言，而他的体现就在于 Java 程序都以类 class 为组织单元。而一个类是对象的抽象，所以类由属性和方法两部分组成。

定义一个类，主要有三个步骤：

1、定义类名，用于区分不同的类。如下代码中 public class 后面跟的就是类名。class是声明类的关键字，类名后面跟上大括号，大括号里面就是类的一些信息。public 为权限修饰符。
下面展示一些。

public class 类名 {
    //定义属性部分（成员变量）
    属性1的类型 属性1;
    属性2的类型 属性2;
    //定义方法部分
    方法1
    方法2
}

一个类可以包含以下类型变量：

局部变量：在方法、构造方法或者语句块中定义的变量被称为局部变量。变量声明和初始化都是在方法中，方法结束后，变量就会自动销毁。
成员变量：成员变量是定义在类中，方法体之外的变量。这种变量在创建对象的时候实例化。成员变量可以被类中方法、构造方法和特定类的语句块访问。
类变量：也叫静态变量，类变量也声明在类中，方法体之外，但必须声明为 static 类型。

对象

创建对象的语法如下：

类名 对象名 = new 类名（）；

比如对 People这个类，我想实例化LiLei这个人。LiLei 的数据类型便是 People 这个类型

People LiLei = new People();

定义类的时候不会为类开辟内存空间，但是一旦创建了对象，系统就会在内存中为对象开辟一块空间，用来存放对象的属性值和方法。

创建对象后，我们就要使用对象了，使用对象无非就是对属性和方法进行操作和调用。语法如下

//引用对象属性
对象名.属性

//引用对象方法
对象名.方法

构造方法

每个类都有构造方法，在创建该类的对象的时候他们将被调用，如果没有定义构造方法，Java 编译器会提供一个默认构造方法。创建一个对象的时候，至少调用一个构造方法。比如在新建一个对象 new Object()，括号中没有任何参数，代表调用一个无参构造方法（默认构造方法就是一个无参构造方法）。构造方法的名称必须与类名相同，一个类可以定义多个构造方法。

构造方法的具体内容：

1、构造方法的名称与类名相同，且没有返回值。它的语法格式如下：

//与类同名，可以指定参数，没有返回值
public 构造方法名(){
//初始化代码
}

构造方法的例子：

public class People{
    //无参构造方法
    public People(){

    }
    //有一个参数的构造方法
    public People(int age){

    }
}

上面的例子中通过 new 关键字将类实例化成对象，而 new 后面跟的就是构造方法。于是可以知道 new + 构造方法可以创建一个新的对象。

2、如果在定义类的时候没有写构造方法，系统会默认生成一个无参构造方法，这个构造方法什么也不会做。

3、当有指定的构造方法时，系统都不会再添加无参构造方法了。

4、构造方法的重载：方法名相同，但参数不同的多个方法，调用时会自动根据不同的参数选择相应的方法。

引用于对象实例

在新建对象实例时，需要为对象实例设置一个对象名，

Object object=new Object();

这里其实只是创建了一个 object 对象的引用。就和指针一样，变量 object 保存的其实 Object 对象的引用，指向了 Object 对象。
下面这个例子中：

Object object1 = new Object();
Object object2 = object1;
System.out.println(object1 == object2);

运行得到的结果为 true，说明 object1 和 object2 的内存地址相同 (== 会比较两个对象的内存地址是否相同），它们实际上是引用同一对象，如果改变 object1 对象内部的属性，那么 object2 的属性同样会改变。

static

静态成员

Java 中被 static 修饰的成员称为静态成员或类成员。它属于整个类所有，而不是某个对象所有，即被类的所有对象所共享。静态成员可以使用类名直接访问，也可以使用对象名进行访问。

如：

 public class StaticTest{
    public static String string="nihao";
    public static void main(String[] args){
        //静态成员不需要实例化 直接就可以访问
        System.out.println(StaticTest.string);
        //如果不加static关键字 需要这样访问
        StaticTest staticTest=new StaticTest();
        System.out.println(staticTest.string);
        //如果加上static关键字，上面的两种方法都可以使用
    }
}

被 static 修饰的方法是静态方法，静态方法不依赖于对象，不需要将类实例化便可以调用，由于不实例化也可以调用，所以不能有 this，也不能访问非静态成员变量和非静态方法。但是非静态成员变量和非静态方法可以访问静态方法。

final

final表面意思就是不可更改的,恒量的意思；指的是无法改变的量，这与静态标量static是有区别的，静态变量指的是只有一份存储空间，值是可以改变的。使用final一定原因是出于软件设计的角度，因为别人看到final这个关键字就知道是什么意思，达到心领神会的效果，但也正是由于这种"语义"的存在，在程序设计中要谨慎使用，以免误用。

final根据修饰位置的不同作用也不相同，针对三种情况：

修饰变量，被final修饰的变量必须要初始化，赋初值后不能再重新赋值。
注意：局部变量不在我们讨论的范畴，因为局部变量本身就有作用范围，不使用private、public等词修饰。
虽然final可以修饰局部变量，但是一般情况下，我们在实际应用中几乎不会这么干，没多大的意义。
修饰方法，被final修饰的方法代表不能重写。
修饰类，被final修饰的类，不能够被继承。
注意：final修饰的类，类中的所有成员方法都被隐式地指定为 final方法。

//静态常量
public final static String ="xaiyule";

封装

封装，即隐藏对象的属性和实现细节，仅对外公开接口，控制在程序中属性的读和修改的访问级别

这样做有什么好处？

只能通过规定的方法访问数据。
隐藏类的实例细节，方便修改和实现

我们在开汽车的时候，只用去关注如何开车，我们并不在意车子是如何实现的，这就是封装。

如何去实现类的封装呢？

修改属性的可见性，在属性的前面添加修饰符 (private)
对每个值属性提供对外的公共方法访问，如创建 getter/setter（取值和赋值）方法，用于对私有属性的访问
在 getter/setter 方法里加入属性的控制语句，例如我们可以加一个判断语句，对于非法输入给予否定。

如果我们没有在属性前面添加任何修饰符，我们通过对象就可以直接对属性值进行修改，没有体现封装的特性。这在许多程序设计中都是不安全的，所以我们需要利用封装，来改进我们的代码。

public class People {
    //属性（成员变量）有什么，前面添加了访问修饰符private
    //变成了私有属性，必须通过方法调用
    private double height;     //身高

    //属性已经封装好了，如果用户需要调用属性
    //必须用getter和setter方法进行调用
    //getter和setter方法需要程序员自己定义
    public double getHeight(){
    //getter 方法命名是get关键字加属性名（属性名首字母大写）
    //getter 方法一般是为了得到属性值
      return height;
    }

    //同理设置我们的setter方法
    //setter 方法命名是set关键字加属性名（首字母大写）
    //setter 方法一般是给属性值赋值，所以有一个参数
    public void setHeight(double newHeight){
      height = newHeight;
    }
}

现在 main 函数里的对象，不能再直接调用属性了，只能通过 getter 和 setter 方法进行调用。

public class NewObject {

    public static void main(String[] args) {
        People LiLei = new People();    //创建了一个People对象LiLei

        //利用setter方法为属性赋值
        LiLei.setHeight(170.0);

        //利用getter方法取属性值
        System.out.println("LiLei的身高是"+LiLei.getHeight());
    }
}

this

this 关键字代表当前对象。使用 this.属性操作当前对象的属性，this.方法调用当前对象的方法。

用 private 修饰的属性，必须定义 getter 和 setter 方法才可以访问到 (Eclipse 和 IDEA 等 IDE 都有自动生成 getter 和 setter 方法的功能）。

如下：

public void setAge(int age) {
  this.age = age;
}
public int getAge() {
  return age;
}

当成员变量和局部变量之间发生冲突时，在属性名前面添加了 this 关键字。此时就代表将一个参数的值赋给当前对象的属性。同理 this 关键字可以调用当前对象的方法.

继承

继承可以看成是类与类之间的衍生关系。比如狗类是动物类，牧羊犬类又是狗类。于是我们可以说狗类继承了动物类，而牧羊犬类就继承了狗类。于是狗类就是动物类的子类（或派生类），动物类就是狗类的父类（或基类）。

所以继承需要符合的关系是：is-a，父类更通用，子类更具体。

语法：

class 子类 extends 父类

例如我们定义了一个 Animal 类，再创建一个 Dog 类，我们需要它继承 Animal 类。

class Dog extends Animal {
    ...
}

为什么需要继承？

如果有两个类相似，那么它们会有许多重复的代码，导致后果就是代码量大且臃肿，后期的维护性不高。通过继承就可以解决这个问题，将两段代码中相同的部分提取出来组成一个父类，实现代码的复用。

继承的特点：

子类拥有父类除 private 以外的所有属性和方法。
子类可以拥有自己的属性和方法。
子类可以重写实现父类的方法。
Java 中的继承是单继承，一个类只有一个父类。

注：Java 实现多继承的一个办法是 implements（实现）接口，但接口不能有非静态的属性。

super

super 关键字在子类内部使用，代表父类对象。

访问父类的属性 super.属性名。
访问父类的方法 super.bark()。
子类构造方法需要调用父类的构造方法时，在子类的构造方法体里最前面的位置：super()。

重写和重载

方法重载

方法重载是指在一个类中定义多个同名的方法，但要求每个方法具有不同的参数的类型或参数的个数。方法重载一般用于创建一组任务相似但是参数不同的方法。

方法重载有以下几种规则：

方法中的参数列表必须不同。比如：参数个数不同或者参数类型不同。
重载的方法中允许抛出不同的异常
可以有不同的返回值类型，但是参数列表必须不同。
可以有不同的访问修饰符。

方法重写

子类可以继承父类的方法，但如果子类对父类的方法不满意，想在里面加入适合自己的一些操作时，就需要将方法进行重写。并且子类在调用方法中，优先调用子类的方法。

比如 Animal 类中有 bark() 这个方法代表了动物叫，但是不同的动物有不同的叫法，比如狗是汪汪汪，猫是喵喵喵。

当然在方法重写时要注意，重写的方法一定要与原父类的方法语法保持一致，比如返回值类型，参数类型及个数，和方法名都必须一致。

多态

多态是指允许不同类的对象对同一消息做出响应。即同一消息可以根据发送对象的不同而采用多种不同的行为方式。多态也称作动态绑定（dynamic binding），是指在执行期间判断所引用对象的实际类型，根据其实际的类型调用其相应的方法。

通俗地讲，只通过父类就能够引用不同的子类，这就是多态，我们只有在运行的时候才会知道引用变量所指向的具体实例对象。

多态的实现条件

Java 实现多态有三个必要条件：继承、重写和向上转型（即父类引用指向子类对象）。

只有满足上述三个条件，才能够在同一个继承结构中使用统一的逻辑实现代码处理不同的对象，从而达到执行不同的行为。

多态的实现方式

Java 中多态的实现方式：继承父类进行方法重写，抽象类和抽象方法，接口实现。

要理解多态必须要明白什么是"向上转型"，比如，一段代码如下，Dog 类是 Animal 类的子类：

Animal a = new Animal();  //a是父类的引用指向的是本类的对象

Animal b = new Dog(); //b是父类的引用指向的是子类的对象

在这里，可以认为由于 Dog 继承于 Animal，所以 Dog 可以自动向上转型为 Animal，所以 b 是可以指向 Dog 实例对象的。

注：不能使用一个子类的引用去指向父类的对象，因为子类对象中可能会含有父类对象中所没有的属性和方法。

如果定义了一个指向子类对象的父类引用类型，那么它除了能够引用父类中定义的所有属性和方法外，还可以使用子类强大的功能。但是对于只存在于子类的方法和属性就不能获取。
向上转型，在运行时，会遗忘子类对象中与父类对象中不同的方法，也会覆盖与父类中相同的方法——重写（方法名，参数都相同）。

抽象类

在定义类时，前面加上 abstract 关键字修饰的类叫抽象类。

抽象类中有抽象方法，这种方法是不完整的，仅有声明而没有方法体。抽象方法声明语法如下：

abstract void f() ; //f()方法是抽象方法

那我们什么时候会用到抽象类呢？

在某些情况下，某个父类只是知道其子类应该包含怎样的方法，但无法准确知道这些子类如何实现这些方法。也就是说抽象类是约束子类必须要实现哪些方法，而并不关注方法如何去实现。
从多个具有相同特征的类中抽象出一个抽象类，以这个抽象类作为子类的模板，从而避免了子类设计的随意性。

所以由上可知，抽象类是限制规定子类必须实现某些方法，但不关注实现细节。

那抽象类如何用代码实现呢，它的规则如下：

用 abstract 修饰符定义抽象类。
用 abstract 修饰符定义抽象方法，只用声明，不需要实现。
包含抽象方法的类就是抽象类。
抽象类中可以包含普通的方法，也可以没有抽象方法。
抽象类的对象不能直接创建，通常是定义引用变量指向子类对象。

例子：
6. 创建一个抽象类 TelePhone.java，填写需要子类实现的抽象方法。

//抽象方法
public abstract class TelePhone {
    public abstract void call();  //抽象方法,打电话
    public abstract void message(); //抽象方法，发短信
}

构建子类，并实现抽象方法。新建一个CellPhone

public class CellPhone extends TelePhone {

    @Override
    public void call() {
        System.out.println("我可以打电话！");
    }

    @Override
    public void message() {
        System.out.println("我可以发短信！");
    }

    public static void main(String[] args) {
        CellPhone cp = new CellPhone();
        cp.call();
        cp.message();
    }

}

添加main方法测试运行结果

我可以打电话！
我可以发短信！

接口

接口用于描述类所具有的功能，而不提供功能的实现，功能的实现需要写在实现接口的类中，并且该类必须实现接口中所有的未实现方法。

接口的声明语法格式如下：

修饰符 interface 接口名称 [extends 其他的接口名] {
        // 声明变量
        // 抽象方法
}

注意点

在 Java8 中：

接口不能用于实例化对象。
接口中方法只能是抽象方法、default 方法、静态方法。
接口成员是 static final 类型。
接口支持多继承。
在 Java9 中，接口可以拥有私有方法和私有静态方法，但是只能被该接口中的 default 方法和静态方法使用。

在 Java9 中，接口可以拥有私有方法和私有静态方法，但是只能被该接口中的 default 方法和静态方法使用。

多继承实现方式：

修饰符 interface A extends 接口1，接口2{

}

修饰符 class A implements 接口1，接口2{

}

实现上面的接口：

// Cat.java
public class Cat implements Animal{

     public void eat(){
         System.out.println("Cat eats");
     }

     public void travel(){
         System.out.println("Cat travels");
     }
     public static void main(String[] args) {
        Cat cat = new Cat();
        cat.eat();
        cat.travel();
    }
}

编译运行：

Cat eats
Cat travels

内部类

将一个类的定义放在另一个类的定义内部，这就是内部类。而包含内部类的类被称为外部类。

内部类的主要作用如下：

内部类提供了更好的封装，可以把内部类隐藏在外部类之内，不允许同一个包中的其他类访问该类
内部类的方法可以直接访问外部类的所有数据，包括私有的数据
内部类所实现的功能使用外部类同样可以实现，只是有时使用内部类更方便
内部类允许继承多个非接口类型

注：内部类是一个编译时的概念，一旦编译成功，就会成为完全不同的两类。对于一个名为 outer 的外部类和其内部定义的名为 inner 的内部类。编译完成后出现 outer.class 和 outer$inner.class 两类。所以内部类的成员变量 / 方法名可以和外部类的相同。

成员内部类

// People.java
//外部类People
public class People {
    private String name = "LiLei";         //外部类的私有属性
    //内部类Student
    public class Student {
        String ID = "20151234";               //内部类的成员属性
        //内部类的方法
        public void stuInfo(){
            System.out.println("访问外部类中的name：" + name);
            System.out.println("访问内部类中的ID：" + ID);
        }
    }

    //测试成员内部类
    public static void main(String[] args) {
        People a = new People();     //创建外部类对象，对象名为a
        Student b = a.new Student(); //使用外部类对象创建内部类对象，对象名为b
        // 或者为 People.Student b = a.new Student();
        b.stuInfo();   //调用内部对象的suInfo方法
    }
}

成员内部类的使用方法：

Student 类相当于 People 类的一个成员变量，所以 Student 类可以使用任意访问修饰符。
Student 类在 People 类里，所以访问范围在类里的所有方法均可以访问 People 的属性（即内部类里可以直接访问外部类的方法和属性，反之不行）。
定义成员内部类后，必须使用外部类对象来创建内部类对象，即内部类对象名 = 外部类对象.new 内部类();。
如果外部类和内部类具有相同的成员变量或方法，内部类默认访问自己的成员变量或方法，如果要访问外部类的成员变量，可以使用 this 关键字。如上述代码中：a.this。

注：成员内部类不能含有 static 的变量和方法，因为成员内部类需要先创建了外部类，才能创建它自己的。

静态内部类

// People.java
//外部类People
public class People {
    private String name = "LiLei";         //外部类的私有属性

/*外部类的静态变量。
Java 中被 static 修饰的成员称为静态成员或类成员。它属于整个类所有，而不是某个对象所有，即被类的所有对象所共享。静态成员可以使用类名直接访问，也可以使用对象名进行访问。
*/
    static String ID = "510xxx199X0724XXXX";

    //静态内部类Student
    public static class Student {
        String ID = "20151234";               //内部类的成员属性
        //内部类的方法
        public void stuInfo(){
            System.out.println("访问外部类中的name：" + (new People().name));
            System.out.println("访问外部类中的ID：" + People.ID);
            System.out.println("访问内部类中的ID：" + ID);
        }
    }

    //测试成员内部类
    public static void main(String[] args) {
        Student b = new Student();   //直接创建内部类对象，对象名为b
        b.stuInfo();                 //调用内部对象的suInfo方法
    }
}

运行：

访问外部类中的name：LiLei
访问外部类中的ID：510xxx199X0724XXXX
访问内部类中的ID：20151234

静态内部类是 static 修饰的内部类，这种内部类的特点是：

静态内部类不能直接访问外部类的非静态成员，但可以通过 new 外部类().成员的方式访问。
如果外部类的静态成员与内部类的成员名称相同，可通过类名.静态成员访问外部类的静态成员；如果外部类的静态成员与内部类的成员名称不相同，则可通过成员名直接调用外部类的静态成员。
创建静态内部类的对象时，不需要外部类的对象，可以直接创建内部类对象名 = new 内部类();。

局部内部类

// People.java
//外部类People
public class People {
    //定义在外部类中的方法内：
    public void peopleInfo() {
        final String sex = "man";  //外部类方法中的常量
        class Student {
            String ID = "20151234"; //内部类中的常量
            public void print() {
                System.out.println("访问外部类的方法中的常量sex：" + sex);
                System.out.println("访问内部类中的变量ID:" + ID);
            }
        }
        Student a = new Student();  //创建方法内部类的对象
        a.print();//调用内部类的方法
    }
    //定义在外部类中的作用域内
    public void peopleInfo2(boolean b) {
        if(b){
            final String sex = "man";  //外部类方法中的常量
            class Student {
                String ID = "20151234"; //内部类中的常量
                public void print() {
                    System.out.println("访问外部类的方法中的常量sex：" + sex);
                    System.out.println("访问内部类中的变量ID:" + ID);
                }
            }
            Student a = new Student();  //创建方法内部类的对象
            a.print();//调用内部类的方法
        }
    }
    //测试方法内部类
    public static void main(String[] args) {
        People b = new People(); //创建外部类的对象
        System.out.println("定义在方法内：===========");
        b.peopleInfo();  //调用外部类的方法
        System.out.println("定义在作用域内：===========");
        b.peopleInfo2(true);
    }
}

运行：

定义在方法内：===========
访问外部类的方法中的常量sex：man
访问内部类中的变量ID:20151234
定义在作用域内：===========
访问外部类的方法中的常量sex：man
访问内部类中的变量ID:20151234

局部内部类也像别的类一样进行编译，但只是作用域不同而已，只在该方法或条件的作用域内才能使用，退出这些作用域后无法引用的。

匿名内部类
匿名内部类，顾名思义，就是没有名字的内部类。正因为没有名字，所以匿名内部类只能使用一次，它通常用来简化代码编写。但使用匿名内部类还有个前提条件：必须继承一个父类或实现一个接口。

例如：

// Outer.java
public class Outer {

    public Inner getInner(final String name, String city) {
        return new Inner() {
            private String nameStr = name;
            public String getName() {
                return nameStr;
            }
        };
    }

    public static void main(String[] args) {
        Outer outer = new Outer();
        Inner inner = outer.getInner("Inner", "NewYork");
        System.out.println(inner.getName());
    }
}
interface Inner {
    String getName();
}

运行结果：Inner。

匿名内部类是不能加访问修饰符的。要注意的是，new 匿名类，这个类是要先定义的, 如果不先定义，编译时会报错该类找不到。

同时，在上面的例子中，当所在的方法的形参需要在内部类里面使用时，该形参必须为 final。这里可以看到形参 name 已经定义为 final 了，而形参 city 没有被使用则不用定义为 final。

然而，因为匿名内部类没名字，是用默认的构造函数的，无参数的，如果需要该类有带参数的构造函数，示例如下：

public Inner getInner(final String name, String city) {
  return new Inner(name, city) {
    private String nameStr = name;

    public String getName() {
      return nameStr;
    }
  };
}

注意这里的形参 city，由于它没有被匿名内部类直接使用，而是被抽象类 Inner 的构造函数所使用，所以不必定义为 final。

package

为了更好地组织类，Java 提供了包机制，用于区别类名的命名空间。

包的作用

把功能相似或相关的类或接口组织在同一个包中，方便类的查找和使用。
包采用了树形目录的存储方式。同一个包中的类名字是不同的，不同的包中的类的名字是可以相同的，当同时调用两个不同包中相同类名的类时，应该加上包名加以区别。
包也限定了访问权限，拥有包访问权限的类才能访问某个包中的类。
定义包语法：

package 包名
//注意：必须放在源程序的第一行，包名可用"."号隔开

//在定义文件夹的时候利用"/"来区分层次
//包中用"."来分层
package com.shiyanlou.java

在这里插入图片描述
如何在不同包中使用另一个包中的类？

使用 import 关键字。比如要导入包 com.shiyanlou 下 People 这个类，import com.shiyanlou.People;。同时如果 import com.shiyanlou.; 这是将包下的所有文件都导入进来，是通配符。

包的命名规范是全小写字母拼写。

mmongin

关注

0
点赞
踩
1

收藏

觉得还不错? 一键收藏
0
评论
面向对象相关知识点（内附举例）

面向对象相关知识点知识点类对象构造方法引用于对象实例staticfinal封装this继承super重写和重载多态抽象类接口内部类package知识点类对于一个具体的对象而言，比如一部 iPhone 6，世上还有许多跟这部手机有着同样属性或行为的对象，我们为了方便将它们归类起来，提取出他们相同的属性和行为，而我们把归类起来的这个抽象的概念，称之为类。类是封装对象的属性和行为的载体，反过来说具有相同属性和行为的一类实体被称为类。类是相同或相似对象的一种抽象，是对象的一个模板，它描述一类对象的行为和状
复制链接

扫一扫