继承的概念

继承是java面向对象编程技术的一块基石，因为它允许创建分等级层次的类。
继承就是子类继承父类的特征和行为，使得子类对象（实例）具有父类的实例域和方法，或子类从父类继承方法，使得子类具有父类相同的行为。
class 父类 {}
class 子类 extends 父类 {}
注意Java不支持多继承，但支持多重继承。

继承的特性

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

重写(Override)

重写是子类对父类的允许访问的方法的实现过程进行重新编写, 返回值和形参都不能改变。即外壳不变，核心重写！
重写的好处在于子类可以根据需要，定义特定于自己的行为。也就是说子类能够根据需要实现父类的方法。

class Animal{
   public void move(){
      System.out.println("动物可以移动");
   }
}
class Dog extends Animal{
   public void move(){
      System.out.println("狗可以跑和走");
   }
}
public class TestDog{
   public static void main(String args[]){
      Animal a = new Animal(); // Animal 对象
      Animal b = new Dog(); // Dog 对象
      a.move();// 执行 Animal 类的方法
      b.move();//执行 Dog 类的方法
   }
}

后续讲到接口的时候会再次提及override

Java 封装

在面向对象程式设计方法中，封装（英语：Encapsulation）是指一种将抽象性函式接口的实现细节部分包装、隐藏起来的方法。
封装可以被认为，是一个保护屏障，防止该类的代码和数据被外部类定义的代码随机访问。
要访问该类的代码和数据，必须通过严格的接口控制。
eg：

public class Person{
    private String name;
    private int age;
    public int getAge(){
      return age;
    }
    public String getName(){
      return name;
    }
    public void setAge(int age){
      this.age = age;
    }
    public void setName(String name){
      this.name = name;
    }
}

其实就是封装类的属性以及set，get方法，外部通过set，get方法来实现对类的修改，这样后面工程合作开发的时候，别人只需要调用你提供的api即可（set，get方法）

Java 接口

接口（英文：Interface），在JAVA编程语言中是一个抽象类型，是抽象方法的集合，接口通常以interface来声明。一个类通过继承接口的方式，从而来继承接口的抽象方法。
接口并不是类，编写接口的方式和类很相似，但是它们属于不同的概念。类描述对象的属性和方法。接口则包含类要实现的方法。
除非实现接口的类是抽象类，否则该类要定义接口中的所有方法。
接口无法被实例化，但是可以被实现。一个实现接口的类，必须实现接口内所描述的所有方法，否则就必须声明为抽象类。另外，在 Java 中，接口类型可用来声明一个变量，他们可以成为一个空指针，或是被绑定在一个以此接口实现的对象。
eg：

package javaSe02;
/**
 * @author hly
 * @Description: TODO
 * @create 2021-07-16 9:03
 */
public interface Animal {
    public void run();
}

package javaSe02;
/**
 * @author hly
 * @Description: TODO
 * @create 2021-07-16 9:04
 */
public class Cat implements Animal{
    @Override
    public void run() {
        System.out.println("cat can run!");
    }
}

接口的作用后续在学习springboot的时候大家会有体会到，一般springboot项目service层有service接口以及serviceimpl是具体的实现类，别人只需要调用service接口，而不需要关心具体的实现逻辑，其实这也是一种封装。

Java 枚举(enum)

Java 枚举是一个特殊的类，一般表示一组常量，比如一年的 4 个季节，一个年的 12 个月份，一个星期的 7 天，方向有东南西北等。
Java 枚举类使用 enum 关键字来定义，各个常量使用逗号 , 来分割。

enum Color
{
    RED, GREEN, BLUE;
}
public class Test
{
    // 执行输出结果
    public static void main(String[] args)
    {
        Color c1 = Color.RED;
        System.out.println(c1);
    }
}

枚举是一个很重要的类，之后的项目中自定义异常会经常用到枚举类

以上基本就是Java面向对象编程的大概内容，可能不够详细，我也只是抓重点给大家学习，所以大家私下得自学多一点。

最后了解一下Java的线程

说到线程有兴趣的同学可以深入了解一下操作系统中线程与进程的区别和联系
我们常常听说XX项目高并发高可用这里讲的就与线程离不了关系
进程线程更详细的解释大家可以下去搜一搜这里通俗的以我的理解讲一讲
进程: 比如在电脑中打开QQ是一个进程你同时又打开了微信又是一个进程
线程: 线程可以理解为进程内部的操作

Java中创建多线程有三种方式分别是
继承线程类实现runnable接口匿名类
实现runnable接口

package wizz;
class MyThread implements Runnable{ // 实现Runnable接口，作为线程的实现类
    private String name ;       // 表示线程的名称
    public MyThread(String name){
        this.name = name ;      // 通过构造方法配置name属性
    }
    public void run(){  // 覆写run()方法，作为线程 的操作主体
        for(int i=0;i<10;i++){
            System.out.println(name + "运行，i = " + i) ;
        }
    }
};
public class RunnableDemo01{
    public static void main(String args[]){
        MyThread mt1 = new MyThread("线程A ") ;    // 实例化对象
        MyThread mt2 = new MyThread("线程B ") ;    // 实例化对象
        Thread t1 = new Thread(mt1) ;       // 实例化Thread类对象
        Thread t2 = new Thread(mt2) ;       // 实例化Thread类对象
        t1.start() ;    // 启动多线程
        t2.start() ;    // 启动多线程
    }
};

继承线程类

class MyThread extends Thread{  // 继承Thread类，作为线程的实现类
    private String name ;       // 表示线程的名称
    public MyThread(String name){
        this.name = name ;      // 通过构造方法配置name属性
    }
    public void run(){  // 覆写run()方法，作为线程 的操作主体
        for(int i=0;i<10;i++){
            System.out.println(name + "运行，i = " + i) ;
        }
    }
};
public class ThreadDemo02{
    public static void main(String args[]){
        MyThread mt1 = new MyThread("线程A ") ;    // 实例化对象
        MyThread mt2 = new MyThread("线程B ") ;    // 实例化对象
        mt1.start() ;   // 调用线程主体
        mt2.start() ;   // 调用线程主体
    }
};

匿名类用的很少，大家自己去了解即可。因为多线程可能在高并发的项目中用的比较多，后续我们布置的项目是很基础的，不会设计高并发，所以多线程就讲到这里，大家如果还有兴趣，可以之后去了解一下线程池，死锁问题（哲学家就餐问题），还有什么是原子类，CAS….等知识。

~~由于上次课程布置的作业，只有个位数的同学提交了，那可能大家对作业有抵触心理，那这次就不布置作业了。~~

JavaSE 第一课

JavaSE-02