【JAVA入门】面向对象

最新推荐文章于 2024-05-01 19:17:00 发布

是阿文呀

最新推荐文章于 2024-05-01 19:17:00 发布

阅读量79

点赞数

文章标签： java 开发语言

本文链接：https://blog.csdn.net/qq_33666822/article/details/126542455

版权

JAVA 专栏收录该内容

9 篇文章 0 订阅

订阅专栏

1. JAVA三大特性

封装、继承、多态

2.面向对象

2.1 本质

面向对象的本质是：以类的方式组织代码，以对象的方式组织数据。

2.2 构造函数

一旦显示定义了有参构造，则类中的无参构造必须显示定义，不能使用默认的无参构造。
可以使用alt+insert，让IDE自动写构造函数。

3. 继承

JAVA中类只有单继承，没有多继承！

3.1 extends

子类继承父类，使用关键字extends来表示。
快捷键Ctrl + H，会在IDE的右侧显示类的树结构。
在JAVA中，所有的类，都默认直接或间接继承Object类。

3.2 super

注意点：
1.super调用父类的构造函数，且必须放在子类构造方法体的第一个。
2.super必须只能出现在子类的方法或构造方法中。
3.super 和 this 不能同时调用构造方法。因为this和super都要求放在构造方法体的第一个。

super VS this

代表的对象不同
this：代表调用者本身
super：代表父类对象的引用
2.前提条件不同：
this：没有继承也可使用
super：只能在继承条件下才可使用
3.构造方法：
this()：本类的构造函数
super()：父类的构造函数

3. 重写

为何需要重写？
父类的功能，子类不一定需要或者子类不一定满足！
重写的条件：
2.1 子类要重写父类的方法，继承是前提；
2.2 子类的方法名必须和父类的方法名相同；
2.3 子类的参数列表必须和父类的参数列表要相同；
2.4 方法的修饰符，子类的修饰符范围可以扩大但不能缩小：public > protected > default > private
2.5 方法抛出的异常，子类范围可以缩小但不能扩大。

重写：子类的方法和父类方法必须要一致，但方法体不同！
** 快捷键：Alt+insert：选择override，IDE可在子类中自动补填重写函数。**

4. 多态

多态的实现，优势在于：在执行时才知道具体执行哪个方法。
注意：多态是方法的多态，属性没有多态性！

4.1 多态实现的三个条件

JAVA中多态的实现同C++中的多态实现：

父类的引用指向子类对象；
子类中的方法是重写父类中的方法；
父子类间要有继承关系。

4.2 无法实现多态的三种函数

以下方法因为无法实现重写，故而无法实现多态：

static 方法。static方法属于类，不属于对象实例。
final修饰的方法，无法被重写。
private修饰的父类方法，无法被子类调用，无法被重写。

4.3 instanceof

instanceof用来判断某个引用对象是否可以指向某个类型的对象。
如下: x instanceof y
若x引用可指向y类型的对象，则返回TRUE，否则返回FALSE。

5. 抽象类

注意点：

同C++，Java中的抽象类不能被实例化，即不能new这个抽象类，只能靠子类去实现这个抽象类。
抽象类中可以有普通方法，但抽象方法必须在抽象类中，即有抽象方法的类必须用abstract关键字声明为抽象类。

// 抽象类
public abstract class Person {
    // 抽象方法：约束，只写一个框架，让子类去实现
    // 抽象方法只有函数声明没有函数体
    public abstract void doSomething();
    public void run() {
    }

    Person(){
        System.out.println("Person Constructor");
    }
}

// 子类在继承抽象类时，必须实现该抽象类中的所有的抽象方法，除非该子类也是个抽象类
public class Student extends Person {
    Student() {
        System.out.println("Student Constructor");
    }
    @Override
    public void doSomething() {

    }

    public static void main(String[] args) {
        Student student = new Student();
    }
}

6.接口

普通类：只有具体实现。
抽象类：具体实现和规范（抽象方法）都有。
接口：只有规范（抽象方法）。将约束和方法分离，真正的面向接口编程。
面向对象的精髓是对对像的抽象，最能体现这一点的就是接口。24种设计模式之所以只针对具备了抽象能力的语言，如C++、Java、C#等，就是因为设计模式研究的就是如何合理地去抽象。
注意：
1. 接口不能被实例化（接口是别抽象类还要抽象的一种规约），接口中没有构造函数。
2. 关键字implements可实现多个接口，实现伪多继承。

6.1 接口声明

声明类的关键字是class，声明接口的关键字是interface。

// 接口类
/* 1.定义接口的关键字是interface。
 * 2.接口定义后一定要有实现类。
 * 3.接口中的所有定义的方法都是public abstract的，故在接口中定义方法，不需要写修饰符。
 */
public interface UserService {
    void add(String name);
    void delete(String name);
    void update(String name);
    void query(String name);
}

注意：接口中定义的属性，其修饰符都是public static final，即都是常量，但一般不会在接口中定义属性。

6.2 接口的实现

1.接口必须要有实现类，实现类使用关键字implements实现接口。
2.接口的实现类的命名一般为在接口后加Impl。
3.Java中类只能单继承，但实现类可实现多个接口，故而达到多继承的目的。
4.一个实现类，必须重写其继承的接口中的所有方法。

/* 1.类可以实现接口。使用关键字implements。
 * 2.实现了接口的类，必须重写接口中的所有方法。
 * 3.接口的实现类，其命名方式为，在接口类后加后缀Impl。
 * 4.Java中类只能单继承，但一个类能实现多个接口，从而达到多继承的目的。
 */
public class UserServiceImpl implements UserService, TimeService{
    @Override
    public void add(String name) {

    }

    @Override
    public void delete(String name) {

    }

    @Override
    public void update(String name) {

    }

    @Override
    public void query(String name) {

    }

    @Override
    public void timer() {

    }
}

7.内部类

内部类就是在一个类的内部再定义一个类。如在类A中定义一个类B，则B相对于A即为内部类，而A相较于B即为外部类。
在一个类文件中，只能有一个public修饰的类，但能有多个类。

7.1 成员内部类

1.通过外部类对象来实例化内部类。
2.内部类可访问外部类的私有属性及方法。

public class OuterClass {
    private int id = 18;

    public void out(){
        System.out.println("外部类方法");
    }

    public class InnerClass{
        // 成员内部类可获取外部类的私有属性及方法
        public void getId(){
            System.out.println(id);
        }

        public void in(){
            System.out.println("内部类方法");
        }
    }
}

public class Application {

    public static void main(String[] args) {
        OuterClass outerClass = new OuterClass();
        // 通过外部类对象来实例化内部类
        OuterClass.InnerClass innerClass = outerClass.new InnerClass();
        innerClass.getId();

    }

}

7.2 静态内部类

静态内部类即在成员内部类的基础上，加上一个static关键字。
静态内部类不能访问外部类中非静态的方法或属性。

public class OuterClass {
    private int id = 18;
    public static class InnerClass{
        public void getId() {
            // 静态内部类不能访问外部类中的非静态成员属性或方法
            // System.out.println(id);
        }
    }
}

7.3 局部内部类

public class OuterClass {
    private int id = 18;

    public void method() {
        // 局部内部类
        class Inner{
            
        }
    }
}

7.4 匿名内部类