Java之面向对象

面向对象

一、基础概念

1、什么是面向对象

万事万物皆可是对象，而了解对象的详细信息，并关注它，这个过程就叫面向对象。面向一个具体的事物进行操作，便面向对象编程。

因为你不会Java啊，来Java中new一个呀，不就有了？

2、Java中的对象

用来描述一个实体，通常由一组属性和对这组属性进行的操作组成。
对象的产生：通过对类的实例化。
对象的”一生“：生成、使用、消除。
当不存在对一个对象的引用时，该对象成为一个无用对象。Java的垃圾收集器自动扫描对象的动态内存区，把没有引用的对象作为垃圾收集起来并释放。当系统内存用尽或调用System.gc( )要求垃圾回收时，垃圾回收线程与系统同步运行。

3、类

类是具有相同属性和方法的一组对象的集合，它为属于该类的所有对象提供了统一的抽象描述，其内部包括属性和方法两个主要部分。在面向对象的编程语言中，类是一个独立的程序单位，它应该有一个类名并包括属性和方法两个主要部分。
Java中的类实现包括两个部分：类声明和类体

4、基本特征

① 封装

封装性就是尽可能的隐藏对象内部细节，对外形成一道边界，只保留有限的接口和方法与外界进行交互。封装的原则是使对象以外的部分不能随意的访问和操作对象的内部属性，从而避免了外界对对象内部属性的破坏。
可以通过对类的成员设置一定的访问权限，实现类中成员的信息隐藏。

几个关键字

private：类中限定为private的成员，只能被这个类本身访问。如果一个类的构造方法声明为private,则其它类不能生成该类的一个实例。
default：类中不加任何访问权限限定的成员属于缺省的（default）访问状态，可以被这个类本身和同一个包中的类所访问。
protected：类中限定为protected的成员，可以被这个类本身、它的子类（包括同一个包中以及不同包中的子类）和同一个包中的所有其他的类访问。
public：类中限定为public的成员，可以被所有的类访问。

② 继承

子类的对象拥有父类的全部属性与方法，称作子类对父类的继承。

Java中父类可以拥有多个子类，但是子类只能继承一个父类，称为单继承。 继承实现了代码的复用。
Java中所有的类都是通过直接或间接地继承java.lang.Object类得到的。
子类不能继承父类中访问权限为private的成员变量和方法。 子类可以重写父类的方法，即命名与父类同名的成员变量。
Java中通过super来实现对父类成员的访问，super用来引用当前对象的父类。super 的使用有三种情况：
访问父类被隐藏的成员变量，如：super.variable;
调用父类中被重写的方法，如：super.Method([paramlist]),super()调用父类构造方法;
调用父类的构造函数，如：super([paramlist]);

③ 多态

对象的多态性是指在父类中定义的属性或方法被子类继承之后，可以具有不同的数据类型或表现出不同的行为。这使得同一个属性或方法在父类及其各个子类中具有不同的语义。

Java的多态性体现在两个方面：由方法重载实现的静态多态性（编译时多态）和方法重写实现的动态多态性（运行时多态）。
编译时多态：在编译阶段，具体调用哪个被重载的方法，编译器会根据参数的不同来静态确定调用相应的方法。
运行时多态：由于子类继承了父类所有的属性（私有的除外），所以子类对象可以作为父类对象使用。程序中凡是使用父类对象的地方，都可以用子类对象来代替。一个对象可以通过引用子类的实例来调用子类的方法。

多态的前提条件
  ①要有继承/实现关系
  ②要有方法重写
  ③要有父类引用指向子类对象

5、扩展

① 重载（Overloading）

方法重载是让类以统一的方式处理不同数据类型的手段。
一个类中可以创建多个方法，它们具有相同的名字，但具有不同的参数和不同的定义。调用方法时通过>传递给它们的不同参数个数和参数类型来决定具体使用哪个方法。
返回值类型可以相同也可以不相同，无法以返回型别作为重载函数的区分标准。

② 重写（Overriding）

子类对父类的方法进行重新编写。如果在子类中的方法与其父类有相同的的方法名、返回类型和参数表，我们说该方法被重写 (Overriding)。
如需父类中原有的方法，可使用super关键字，该关键字引用了当前类的父类。 子类函数的访问修饰权限不能低于父类的。

注：Java中的重载与重写的区别：
  1、重载发生在本类，重写发生在父类与子类之间；
  2、重载的方法名必须相同，重写的方法名相同且返回值类型必须相同；
  3、重载的参数列表不同，重写的参数列表必须相同。

二、升级一下思绪

1、深入探讨一下三大特性

在你已经阅读完上述的基础概念过后,相信你已经有所了解，接下来我们就去深入探讨一下这个久闻大名的三大特性吧!

① 封装

  一、封装的定义方法

首先我们可以看到封装的特性可以得到封装的一个特性——>安全性。那么我们哪些”不为人知“的参数怎么去见人呢？就和我们看电视的洗钱一样呀，得用点手段呀；当然，这肯定不是犯罪，所以手段也不是什么传说中的黑客！！！就是在我们想要别人能读取，遵循我们的规则就好了，就让它可以用set()/get()方法来对我们封装好的类进行使用呀。

例：下面这个就是一个典型的封装‘人’类，将人的姓名、性别等封装起来，需要时直接调用就可了。
看完上面的图片后，我相信你应该有以下几个疑问：

图片中的this是什么意思？

  在Java的继承中，我们使用某些方法设置时，为了方便对比，我们就会定义与类同样的变量名，而this关键字就可以区别出来我们指的是那个变量，比如图中的this.id就是指的Person类中定义的私有id，后面的id则是setId(int id)方法中传入的这个id。

封装类里面只能由set/get方法组成？

  不，封装类可以不只是由set/get方法，我们也可以定义其他方法，比如说我下面要定义一个show方法来显示这个人的某些信息，在这里也可以发现，我并没有使用this关键字，也可以调用到我类中的变量，可以知道，当变量名不重复时，我们的变量访问遵循了就近原则。

假如我定义这么多变量要一个一个写get/set方法，还有无参由有参的函数岂不是很难写？

  倘若你要一个一个的去敲的话，这个确实很多，但是我们发现这些函数其实也差不多，多以肯定由快捷方式呀下面分享一下：

两种方法：一、按下ALT+Insert或者鼠标右击空白处
下面的截图时鼠标点击出现的两个截图，用快捷键可以直接到右边那一步。直接生成构造函数和set/get方法即可，在我们学习过程中为了方便我们对封装函数的调用，我们构造函数的时候，最好将有参和无参函数都构造好。
        

  二、封装函数的调用

1、无参访问
无参访问时我们需要将参数实例化后，直接调用set方法进行设置我们需要的值就可以了，比如我下面这一串代码

		person p2 = new person();
        p2.setName("pier");
        p2.setId(18);
        p2.show();

运行结果

身份证:18性别null出生日期null姓名pier

有参访问几句简单很多了，直接将我们的参数传入进去就可以了没有的可以直接

person p =new person(18,"男","pipi",Date.from(Instant.now()));
p.show();

运行结果(这里由于没有专门去设置时间格式，就直接调用当前时间，格式就不太对，但无伤大雅)

身份证:18性别男出生日期Thu Aug 12 10:50:28 CST 2021姓名pipi

② 继承

在世界的大多数国家中，都有一项继承法。其中的第一继承者就是配偶和子女；是的，这个继承也那个意思一样不过不是继承部分，而是全部都可以继承，简单来说就是，你父类中有的只要不是只能自己用的，我都可以有并且可以使用，你父类中没有的，我也可以有，就算你有多个子类，但这并不影响我继承呀。这一特性就可以让我们的代码有一个什么样的特性呢——>复用性。

  看看继承在现实中的含义叭
            
  上图中我们可以看到无论是兔子、小羊羔这类食草动物，还是狮子和猎豹这类食肉动物都是动物，我们就可以将动物定义成一个父类，而其他的兔子、狮子等动物都可以继承动物这个类。那么为什么我们要将动物当作我们的父类呢？因为呀他们有一个共同的特性，比如吃东西（吃草，吃肉）等特性，我们就可以将他们共同的特性定义在我们的父类中，而在子类中在将我们各种动物不同的地方定义出来，比如兔子吃草，有两个大耳朵，狮子吃肉，有锋利的牙齿，吃东西可以继承动物，而不同的特性就可以另外定义以下。下面我们看看动物的例子叭：
动物类(父类)

public class Animal {
    private String name;

    public Animal(){

    }
    public Animal(String name) {
        this.name = name;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }
    public void eat(String s){
        System.out.println("我是"+getName()+",我可以吃"+s+"呢");
    }
}

狮子类(子类一)

public class Lion extends Animal{
    public Lion() {
    }

    public Lion(String name) {
        super(name);
    }
}

兔子类(子类二)

public class rabbit extends Animal{
    public rabbit(){

    }
    public rabbit(String name){
        super();
    }
    public void jumpping(){
        System.out.println("我还会跳");
    }
}

测试类

public class Demo {
    public static void main(String[] args) {
        rabbit rb = new rabbit();
        rb.setName("兔子");//调用的就是继承的方法
        rb.eat("草");
        rb.jumpping();//这里调用的就是兔兔的特有方法
        LionLo = new Lion();
        Lo.setName("狮子");
        Lo.eat("肉肉");
    }
}

运行结果

我是兔子,我可以吃草呢
我还会跳
我是狮子,我可以吃肉肉呢

总结以下几点

继承的关键字extends
子类拥有父类非 private 的属性、方法。
子类可以拥有自己的属性和方法，即子类可以对父类进行扩展。
子类可以用自己的方式实现父类的方法（支持重写）。
Java 的继承是单继承，但是可以多重继承，单继承就是一个子类只能继承一个父类，多重继承就是，例如 B 类继承 A 类，C 类继承 B 类，所以按照关系就是 B 类是 C 类的父类，A 类是 B 类的父类，这是 Java 继承区别于 C++ 继承的一个特性。
代码的复用性升高，也就提高了类之间的耦合性（继承的缺点，耦合度高就会造成代码之间的联系越紧密，代码独立性越差）。

③多态

为什么需要多态

我们在上面的收可以看到的是继承的缺点就是耦合性太高导致独立性太差，那出现多态就是为了解决这个耦合性过高的问题的呀。多态可以做到多对象使用不混乱，可以让我们的程序具有通用性。

在基础的时候上面我们可以看到到的多态的前提条件有继承，那我们将上面的Lion函数和Demo函数改变一下，看看最后的结果：
改变后的Lion

public class Lion extends Animal{
    public Lion() {
    }
    public Lion(String name) {
        super(name);
    }

    @Override
    //重写父类中的eat方法
    public void eat(String s) {
    	//在调用父类中的方法时需要使用super关键字
    	super.eat(s);
        System.out.println("勇敢牛牛，不怕困难");
    }
}

Demo(测试类)

public class Demo {
    public static void main(String[] args) {
        Animal Lo = new Lion();
        Lo.setName("狮子");
        Lo.eat("肉肉");
    }
}

运行结果

我是狮子,我可以吃肉肉呢
勇敢牛牛，不怕困难

进程已结束,退出代码0

**注：当使用多态方式调用方法时，首先检查父类中是否有该方法，如果没有，则编译错误；如果有，再去调用子类的同名方法。
多态的好处：可以使程序有良好的扩展，并可以对所有类的对象进行通用处理。
**

2、 类→抽象类、接口

  我们先一起看看什么是抽象类和接口

抽象类往往用来表征对问题领域进行分析、设计中得出的抽象概念，是对一系列看上去不同，但是本质上相同的具体概念的抽象。
注：一个类中如果有抽象方法(抽象方法指的是没有具体实现的方法实现)，那么这个类必须是一个抽象类。注意，抽象类里面是不能创建对象的。

接口：Java接口是一系列方法的声明，是一些方法特征的集合，一个接口只有方法的特征没有方法的实现，因此这些方法可以在不同的地方被不同的类实现，而这些实现可以具有不同的行为（功能）。注意：接口中也是不能创建对象。

有的小伙伴看到了上面的描述，可能会有一个疑惑，既然要一个不知道怎样的方法，那么直接创建一个空方法体不就行了吗？其实在使用抽象类，类的使用者创建对象的时候，就知道他必须要使用某个具体子类，而不可能误用不完整的父类。就可以知晓使用时必须实现该方法，这就是抽象类的作用。
接口的作用就是在项目中，有一些功能，不仅仅是一个类去实现，即有很多地方有用到，大家需要统一标准。所以需要用接口，这样大家同时实现一个接口，就能够统一规范。在接口中只是定义了基本的方法名，具体的实现交给实现类。

抽象类和接口的区别
成员区别
  抽象类:常量；构造方法；抽象方法；非抽象方法
  接口: 常量；抽象方法
关系区别
  类与类: 单继承
  类与接口: 实现，可多实现
  接口和接口: 继承，可多继承
设计理念区别
  抽象类：对类抽象，包括属性、行为,完成的是一些共性功能的抽取
  接口：对行为抽象，主要是行为，完成的是一些特性功能的提取

3、异常

① 什么是异常

一般的异常分为运行时异常和非运行时异常，这里就将它再细分以下几种：

异常是程序中的一些错误，但并不是所有的错误都是异常，并且错误有时候是可以避免的。
检查性异常：最具代表的检查性异常是用户错误或问题引起的异常，这是程序员无法预见的。例如要打开一个不存在文件时，一个异常就发生了，这些异常在编译时不能被简单地忽略。
运行时异常： 运行时异常是可能被程序员避免的异常。与检查性异常相反，运行时异常可以在编译时被忽略。
错误： 错误不是异常，而是脱离程序员控制的问题。错误在代码中通常被忽略。例如，当栈溢出时，一个错误就发生了，它们在编译也检查不到的。

你能区分以下是那种异常吗?

你的代码少了一个分号，那么运行出来结果是提示是错误 java.lang.Error；如果你用System.out.println(11/0)，那么你是因为你用0做了除数，会抛出 java.lang.ArithmeticException 的异常。
异常发生的原因有很多，通常包含以下几大类：
用户输入了非法数据。
要打开的文件不存在。
网络通信时连接中断，或者JVM内存溢出。
这些异常有的是因为用户错误引起，有的是程序错误引起的，还有其它一些是因为物理错误引起的。-

② 怎么处理异常

在程序中的异常一般由两种处理方式
①往外抛：不管程序报错，直接往外抛，这种一般是Java自带的处理异常的方式，就是不管异常，知道程序自己报错
②捕获异常：一般这个就是用try(){}catch(){}来捕获异常值并抛出，我们这里主要是了解这一种处理异常的方式
下面我就用一个最常见的数组超出长度的异常来演示一下：

正常输出

    public static void main(String[] args) {
        int[] arr = {1,2,3};
        for (int i = 0; i < arr.length; i++) {
            System.out.print(arr[i]+"\t");
        }
    }

输出结果

1 2 3
进程已结束,退出代码0

异常：字符串长度超过异常

方法一：往外抛

public static void main(String[] args) {
        int[] arr = {1,2,3};
        for (int i = 0; i < arr.length+1; i++) {
            System.out.print(arr[i]+"\t");
        }
        System.out.println("输出完毕！");
    }

运行结果

1 2 3 Exception in thread “main” java.lang.ArrayIndexOutOfBoundsException: Index 3 out of bounds for length 3
进程已结束,退出代码1

这里就可以看到异常为Index 3 out of bounds for length 3，即数组长度超过最大长度，并且并没有执行我们后面的输出语句，直接在异常点姐结束了运行。

方法二:try/catch

public static void main(String[] args) {
        int[] arr = {1,2,3};
        try {
            for (int i = 0; i < arr.length + 1; i++) {
                System.out.print(arr[i] + "\t");
            }
        }catch (Exception e){
            System.out.println("你的数组长度不符合要求\n异常为:"+e);
        }
        System.out.println("输出完毕！");
    }

运行结果

1 2 3 你的数组长度不符合要求
异常为:java.lang.ArrayIndexOutOfBoundsException: Index 3 out of bounds for length 3
输出完毕！

进程已结束,退出代码0

这里的就可以看到我们虽然也出现了异常，但是并不影响我们程序后面的运行，依旧将我们后面的代码给执行下去了。

总计

在出现我们不确定是否会有出现不确定因素时，我们可以加一个捕捉异常的方法，这样不会影响我们的代码最终运行，比如我们数组的长度不确定时，需要传入字符时等一些情况，都可以加上。

三、 浅出总结

  做一个项目时，将类中的某些东西私有化，想让人调用的就设置一下get/set方法，不想的就直接private私有化，在我的类中有很多和另一个类相似的，定义一个父类，将相似的地方包起来，在继承，能够减少代码的冗余，当我要用的和父类不一样时我们就重写一下父类的方法，一样的直接使用super调用就可。要是不知道怎么形容父类，就用一个抽象类去定义，当一个项目由多个人完成时，我们的每个人都不一样，就需要定义一个标准，就是定义一个接口，为大家做一个模板。程序中总会有一些不可控硬塑，在我们可能出错的地方就将异常加上去，把异常给抛出来，不影响整个项目的运行，这样一整个普通的项目就做好了。

附：感谢您的阅读，这么长的一篇文章，希望对您能有所收获呀！