乐趣区

关于思否技术征文:从前端到全栈-最全面向对象总结

jiezi

本文参加了思否技术征文，欢送正在浏览的你也退出。

从事前端的这两年中，也接触了后端畛域，像 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();}
  1. 接口中能够含有变量，然而接口中的变量会被隐式的指定为 public static final 变量（并且只能是 public，用 private 润饰会报编译谬误）。
  2. 接口中的办法是不能在接口中实现的，只能由实现接口的类来实现接口中的办法。

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 面向对象 的总结分享，心愿能对你有所启发，欢送提出意见！

退出移动版