Java面向对象

Java面向对象

初识面向对象

面向过程&面向对象

面向过程

​ 步骤清晰简单，第一步做什么，第二步做什么……

​ 适合处理简单问题

面向对象

​ 物以类聚，分类的思维模式，首先解决问题是需要那些分类。

​ 适合处理复杂问题，如多人协作的问题

---

​ 对于描述复杂的事物，宏观上需要用面向对象的思路来分析，对于具体的微观操作，仍需要面向过程的思路去处理

---

什么是面向对象

​ 面向对象编程（Object-Oriented Programming，OPP）

​ 面向对象编程的本质就是：以类的方式组织代码，以对象的组织（封装）数据。

​ 从认识的角度，先有对象后有类。对象，是具体的事物；类，是抽象的，是对对象的抽象

​ 从代码运行角度，先有类后有对象。类是对象的模板。

---

对象的创建分析

类与对象的关系

​ 类是一种抽象的数据类型，它是对某一类事物的整体描述/定义，但是并不能代表某一个具体事物

​ 对象是抽象概念的具体实例

创建与初始化对象

​ 使用new关键字创建的时候，除了分配内存空间之外，还会给创建好的对象进行默认的初始化以及对类中构造器的调用。

​ 类中的构造器也称为构造方法，是在创建对象的时候必须调用的。并且构造器有以下两个特点：

• 必须和类的名字相同
• 必须没有返回值，void也不行

---

​

面向对象三大特性

封装

• 该露的露，该藏的藏
  • 我们程序设计追求“高内聚，低耦合”。高内聚：类的内部数据操作细节自己完成，不允许外部干涉；低耦合：仅暴露少量的方法给外部使用。
• 封装（数据的隐藏）
  • 通常，应禁止直接访问一个对象中数据的实际表示，而应通过操作接口来访问，这成为信息隐藏。

​ => 属性私有（private）并提供一些public的get、set方法

继承

• 继承的本质是对某一批类的抽象
• extands的意思是“扩展”。子类是父类的扩展，可以继承父类的所有方法
• 私有的（private）的内容，是不能继承的
• IDEA Ctrl+H可以查看类继承关系
• is a关系

​ public对外部完全可见。proteced对本包和所有子类可见。private仅对本类可见。默认对本包可见，不需要修饰符。

super

​ 默认与this使用本类的方法，super使用超类的方法

public void test(){
    print();//调用本类的print方法
    this.print();//调用本类的print方法
    super.print();//调用超类（父类）的print方法
}

​ 调用父类的构造器，必须在构造方法的第一个。

​ 只能在继承条件下才可以使用。

方法重写

​ 重载 ≠ 重写

​ 重写都是方法的重写，与属性无关

​ 重写是子类对父类的允许访问的方法的实现过程进行重新编写, 返回值和形参都不能改变。

多态

​ 多态方式调用方法时,首先检查父类中是否有该方法,如果没有,则编译错误;如果有,再去调用子类的同名方法。

​ 对象能执行哪些方法，主要看对象左边的类型，和右边关系不大

​ 父类的引用指向子类，若子类重写了父类的方法，执行子类的方法

​ 父类型可以指向子类，但是不能调用子类独有的方法

​ 子类型能调用的方法是自己的或继承父类的

抽象类和接口

抽象类

​ abstract 抽象修饰符，可抽象类和方法

​ 类 extends：单继承 （但接口可以多继承）

​ 抽象方法只有方法名字，没有方法的实现

​ 抽象类无法new，只能靠子类去实现它：约束

​ 抽象类中可以写普通的方法

​ 抽象方法必须在抽象类中

接口

• 普通类：只有具体实现
• 抽象类：具体实现和规范（抽象方法）都有
• 接口：只有规范！自己无法写方法（专业的抽象） => 约束和实现分离：面向接口编程

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

​ 简单代码示例：

// interface 定义的关键字 ， 接口都需要有实现类

public interface UserService {
    //接口中的所有定义其实都是抽象的 public abstract
    void run();
    public abstract void run(String name); //public abstract 是灰色的，不用写也是默认该类型

    //接口内可以生成常量 public static final
    int AGE = 99;

    void add(String name);
    void delete(String name);
    void update(String name);
    void query(String name);

}

public interface TimeService {
    void timer();
}

//抽象类：extends
// 类可以实现接口 implement 接口
//实现了接口的 类，就需要 重写 接口中的方法

//多继承 利用接口实现多个继承
public class UserServiceImpl implements UserService,TimeService{

    @Override
    public void run() {

    }

    @Override
    public void run(String name) {

    }

    @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() {

    }
}

​ 作用：

• 1.约束
• 2.定义一些方法，让不同的人去实现
• public abstract
• public static final
• 接口不能被实例化，接口中没有构造方法
• implements 可以实现多个接口
• Impl类必须要重写接口中的方法（impl首字母大写) （@Override => 重写）

---

内部类及OOP实战

​ 内部类就是在一个类的内部再定义一个类。

• 成员内部类
  • 成员内部类可以使用外部类的私有属性和方法（public）
• 静态内部类
  • 无法访问非静态的属性（public static）
• 局部内部类
  • 方法内的类
• 匿名内部类
  • 没有名字去初始化类，不用将实例保存在变量中

​ 内部类代码示例：

public class innerClass {
    public static void main(String[] args) {
        var clock = new TalkingClock(1000,true);
        clock.start();
        JOptionPane.showMessageDialog(null, "Quit program?");
        System.exit(0);
    }

}


class TalkingClock{
    private int interval;
    private boolean beep;

    //alt+insert构造函数，一键构造类构造器
    public TalkingClock(int interval, boolean beep) {
        this.interval = interval;
        this.beep = beep;
    }

    public void start(){
        var listener = new TimePrinter();
        var timer = new Timer(interval,listener);
        timer.start();
    }
    public class TimePrinter implements ActionListener{
        @Override
        public void actionPerformed(ActionEvent event) {
            System.out.println("At the tone, the time is" + Instant.ofEpochMilli(event.getWhen()));
            if(beep) Toolkit.getDefaultToolkit().beep();
        }
    }

    public void start2(){
        //声明局部内部类时不能有访问说明符（即public或private）
        // 局部类对外部世界完全隐藏，即使TalkingClock类中的其他代码也不能访问他，除start2外，没有任何方法知道TimePrinter2类的存在
        class TimePrinter2 implements ActionListener{
            public void actionPerformed(ActionEvent event){
                System.out.println("At the tone, the time is" + Instant.ofEpochMilli(event.getWhen()));
                if(beep) Toolkit.getDefaultToolkit().beep();
            }
        }
    }

    /*
    一般的，匿名类语法如下：
    new SuperType(construction parameters)
    {
        inner class methods and data
    }
    //SuperType 可以是接口也可以是类，如果是接口要实现接口，如果是类需要扩展这个类
    //匿名内部类没有类名。因此没有构造器
    //内部类实现一个接口，不能有任何构造参数，但依然需要小括号
    new InterfaceType(){
        methods and data
    }
     */
    public void start(int interval, boolean beep){
        var listener = new ActionListener()//创建一个类的新对象
        {
            //实现的方法在括号内定义-> 实现了ActionListener接口
            public void actionPerformed(ActionEvent event)
            {
                System.out.println("At the tone, the time is" + Instant.ofEpochMilli(event.getWhen()));
                if(beep) Toolkit.getDefaultToolkit().beep();
            }
        };
        var timer = new Timer(interval, listener);
        if(beep) Toolkit.getDefaultToolkit().beep();
        timer.start();
    }

    //运用lamda表达式
    public void start2(int interval, boolean beep){
        var timer = new Timer(interval, event->{
            System.out.println("At the tone, the time is" + Instant.ofEpochMilli(event.getWhen()));
            if(beep) Toolkit.getDefaultToolkit().beep();
        });
        timer.start();
    }
}

静态内部类代码示例：

public class staticInnerClass {
    public static void main(String[] args) {
        var values = new double[20];
        for(int i = 0; i<values.length; i++)
            values[i] = Math.random()*100;
        ArrayAlg.Pair p = ArrayAlg.minmax(values);
        System.out.println("min = " + p.getFirst());
        System.out.println("max = " + p.getSecond());

    }
}

//使用内部类最吸引人的原因是：
//每个内部类都能独立的继承自一个(接口的)实现，所以无论外围类是否已经继承了某个(接口的)实现，对内部类都没有影响。
//内部类有效的实现了“多重继承”。也就是说，内部类允许继承多个非接口类型(类或者抽象类)。
//使用内部类还可以获得其他一些特性
//1. 内部类可以有多个实例，每个实例都有自己的状态信息，并且与外围类对象的信息相互独立。
//2. 在单个外围类中，可以让多个内部类以不同的方式实现同一个接口，或继承同一个类。
//3. 创建内部类对象的时刻并不依赖于外围类对象的创建。
//4. 内部类并没有令人迷惑的 “is-a”关系；它就是一个独立的实体。

class ArrayAlg
{
    //静态内部类Pair
    //为了把一个类隐藏在另一个类的内部，并不需要内部类有外围类对象的一个引用。(不需要外围的信息）
    public static class Pair {
        private double first;
        private double second;

        public Pair(double first, double second) {
            this.first = first;
            this.second = second;
        }

        public double getFirst() {
            return first;
        }

        public double getSecond() {
            return second;
        }

    }

    public static Pair minmax(double[] values)
    {
        double min = Double.POSITIVE_INFINITY;
        double max =Double.NEGATIVE_INFINITY;
        for (double v: values)
        {
            if (min>v) min = v;
            if (max<v) max = v;
        }
        return new Pair(min,max);
    }

}

static补充

​ 静态代码块首先执行并只运行一次，匿名代码块后执行且每new一个对象就会执行一次，后执行构造方法

public class Person {

    public Person(){
        System.out.println("构造方法");
    }

    //第二执行，且能执行多次 => 用于赋初始值  跟对象同时产生
    {
        System.out.println("匿名代码块");
    }

    //最早执行且执行一次
    static {
        System.out.println("静态代码块");
    }

    public static void main(String[] args) {
        Person person1 = new Person();
        System.out.println("====================");
        Person person2 = new Person();
        System.out.println("====================");
        Person person3 = new Person();
    }
}

/*
输出结果为：
    
静态代码块
匿名代码块
构造方法
====================
匿名代码块
构造方法
====================
匿名代码块
构造方法
*/    

---

​ 静态导入包补充

//静态导入包
import static java.lang.Math.random;

public class Test {
    public static void main(String[] args) {
        //若无静态导入包
        System.out.println(Math.random());
        //静态导入包后可将Math省略
        System.out.println(random());
    }
}