从前端到全栈 -- 最全面向对象总结

本文参与了思否技术征文，欢迎正在阅读的你也加入。

从事前端的这两年中，也接触了后端领域，像 PHP Node, 并且都用它们做过一些 demo 和 私活 ,
站在职业发展道路上来讲，了解后端是好的，自己可以熟练前后的开发流程，整条链路下来，很清晰，懂了后端，在自己以后创业或者接私活，都是不错的。 而且现在在Web后台领域, Java 是 老大哥了，Spring 全家桶走遍天下，于是最近又重拾 Java 了，从前端迈向全栈

这是我最近花了一周的时间复盘的 Java 面向对象 总结，希望能帮助到你.

导读目录

学习路线

这份学习路线 是 我跟着 某up主 视频总结的，很全面

重学Java

一、面向对象 OOP

1. 1 关于 super 和 this 区别

super

1. super 调用父类的构造方法，必须在子类构造方法中第一个
2. super 必须只能出现在子类的方法 或者 构造方法 中
3. super 和 this 不能同时出现在调用构造方法

this

代表的对象不同:

1. this : 本身调用者这个对象
2. super : 代表父类对象应用

1.2 多态

同一方法可以根据发送对象的不同而采用多种不同的行为方式。

一个对象的实际类型是确定的，但可以指向对象的引用类型有很多。

多态存在条件

1. 有继承关系
2. 子类重写父类的方法
3. 父类引用指向了子类对象

注意

1. 子类如果重写了父类方法，父类对象是调用的子类重写后的方法

类型转换

类型转换目的： 方便方法调用，降级，升级，减少代码重复性，但也有缺点，丢失精度性

1. 向上转型 (子 转 父 ) 低转高 可直接转

2. 向下转型 （父 转 子） 高转低 需要强制转换

   高 转 低 后， 然后再进行强制转换，

   子类型 子对象 = (子类型) 父对象

    Person per = new Student()
    Student student = (Student) per   //  ((Student) per).方法/属性
    
    per.子属性和方法

1.3 static

1.3.1 static 用途

在没有创建对象的情况下调用方法和属性(静态的)。

static 可以用来修饰类的成员方法、类的成员变量，另外可以编写static代码块来优化程序性能。

1.3.2 static 静态方法

1. static 方法一般称作静态方法,静态方法不依赖于任何对象就可以进行访问, 因此对于静态方法来说，是没有this的。
2. 在静态方法中不能访问类的非静态成员变量和非静态成员方法，因为非静态成员方法/变量都是必须依赖具体的对象才能够被调用。
3. 在非静态方法中是可以访问静态成员方法/变量的。

1.3.3 static 静态变量

静态变量和非静态变量的区别是

1. 静态变量被所有的对象所共享，在内存中只有一个副本，它当且仅当在类初次加载时会被初始化。
2. 非静态变量是对象所拥有的，在创建对象的时候被初始化，存在多个副本，各个对象拥有的副本互不影响。

static成员变量的初始化顺序按照定义的顺序进行初始化。

1.3.4 static 代码块

static关键字来形成静态代码块以优化程序性能,。

static块可以置于类中的任何地方，类中可以有多个static块。在类初次被加载的时候，会按照static块的顺序来执行每个static块，并且只会执行一次。

可以把方法中常量放入到 静态块中，这样不至于，每次调用，又重新创建，造成空间浪费。

public class Test {
    private  static Date date ;
    private  static SimpleDateFormat formatter;
    static {
         formatter= new SimpleDateFormat("yyyy-MM-dd 'at' HH:mm:ss z");
         date = new Date(System.currentTimeMillis());
    }
    public static void main(String[] args) {
        getTime();
    }
    public static void  getTime(){
        System.out.println(formatter.format(date));
    }
}

以上例子是 用来获取当前时间，在调用getTime 静态方法时，它不会重复创建Date SimpleDateFormat

执行顺序： 优于构造器

1.3.5 static 注意

1. static关键字不能会改变类中成员的访问权限， 能改变访问权限只有 private、public、protected.

2. 通过 this 可以在非静态方法中是可以访问静态方法和静态成员的

   public class Test {
       private  static Date date ;
       private  static SimpleDateFormat formatter;
       private  static String name = "前端自学社区";
       
       public static void main(String[] args) {
            Test test = new Test();
            test.getStatic();
       }
       public static void func(){
           System.out.println("我是静态方法");
       }
       public  void getStatic(){
           System.out.println(this.name);
           this.func();
       }
   }

   例子中，在非静态方法中，可以直接通过 this 来进行访问的静态方法和静态成员 ，然后通过类实例化后，对象即可通过非静态方法来获取到静态方法中得静态属性和方法。

1.4 抽象类 abstract

我们先来了解一下抽象方法，抽象方法是一种特殊的方法：它只有声明，而没有具体的实现。

抽象方法的声明格式为：

abstract int getNum();

1.4.1何为 抽象类 呢 ?

被 abstract关键词修饰的类就是抽象类，抽象类含有属性和抽象方法。

抽象类中含有无具体实现的方法，所以不能用抽象类创建对象。

当 子类 继承 了 抽象类 ，那么必须的实现抽象类的抽象方法，同时 子类的实例化对象拥有抽象类的属性。

public abstract class Animal {
    abstract String name;
    abstract void eat();
}

1.4.2 抽象类作用？

抽象类主要用来抽离事物的共性，抽离出属性和方法，子类 继承 抽象类，提高代码效率。

1.4.3 抽象类与普通类区别

1. 抽象方法必须为public或者protected（因为如果为private，则不能被子类继承，子类便无法实现该方法），缺省情况下默认为public。
2. 抽象类不能用来创建对象；
3. 如果一个类继承于一个抽象类，则子类必须实现父类的抽象方法。如果子类没有实现父类的抽象方法，则必须将子类也定义为为abstract类。

1.5 接口 interface

1.5.1 什么是接口？

它是对行为的抽象，接口通常以interface来声明。一个类通过继承接口的方式，从而来继承接口的抽象方法。

当一个类需要用到这些抽象行为的话，需要 实现接口 implements , 而且必须实现接口中方法。

public interface person {
    void study(){}  
}

1.5.2 接口特性

1. 接口中每一个方法也是隐式抽象的,接口中的方法会被隐式的指定为 public abstract（只能是 public abstract，其他修饰符都会报错）。 也可不写，默认就是public abstract 。

   public interface Aniaml{
       public abstract void eat(); // 抽象方法 == 等同于  void eat();
   }

2. 接口中可以含有变量，但是接口中的变量会被隐式的指定为 public static final 变量（并且只能是 public，用 private 修饰会报编译错误）。
3. 接口中的方法是不能在接口中实现的，只能由实现接口的类来实现接口中的方法。

1.5.4 接口的作用

1. 使用接口可以继承超过一个以上的来源，这样可以为不同的需求组合出不同的继承层次。
2. 接口规范了实现类，必须实现的方法和属性。

1.6 接口与抽象类

在Java中，可以通过两种形式来体现OOP的抽象：接口和抽象类, 它俩有很多相似之处。

1.6.1 接口与抽象 区别

1. 抽象类可以提供成员方法的实现细节，而接口中只能存在public abstract 方法；
2. 抽象类中的成员变量可以是各种类型的，而接口中的成员变量只能是public static final类型的；
3. 接口中不能含有静态代码块以及静态方法，而抽象类可以有静态代码块和静态方法；
4. 一个类只能继承一个抽象类，而一个类却可以实现多个接口。
5. interface 接口 是针对事物的 行为 [ 方法 ] 来进行抽象的， 而 抽象类 是针对事物的共性来 对 行为 和 属性 来进行抽象的。

1.6.2 例子

接口 interface

public interface PeopleInterface {
    void eat();
    void study();
    void play();
}

抽象类 abstract

public abstract class People {
   String name = "人类";
    abstract void watch();
}

子类

public class Test extends People implements PeopleInterface {
    public static void main(String[] args) {
        Test test = new Test(); // 子类拥有抽象类的属性
        System.out.println(test.name);
        test.eat();
    }

    @Override
    public void eat() {
        System.out.println("吃的功能");
    }

    @Override
    public void study() {
        System.out.println("学习功能");
    }

    @Override
    public void play() {
        System.out.println("玩的功能");
    }

    @Override
    void watch() {
        System.out.println("看的功能");
    }

}

上面例子中讲了 类 与 接口 抽象类之间关系。 首先 Test 类 继承了 People 抽象类，然后又 实现了 PeopleInterface 接口。

子类继承 抽象类的同时，必须实现抽象类的抽象方法，子类实例化时，拥有抽象类的属性。

子类实现 接口的同时， 必须实现接口中所有的接口行为。

结语

以上是对Java 面向对象 的总结分享，希望能对你有所启发，欢迎提出意见！