• 继承：是指在一个现有类的基础上去构建一个新的类，构建出来的新类被称作子类，现有类被称作父类，子类会自动拥有父类所有
• 继承的好处：可继承的属性和方法。
  1.  

•                             提高了代表的可维护性

                              提高了代码的复用性

                              让类与类之间产生了继承关系

• 1. 继承的弊端：

•                             类与类之间的耦合度过高

• 1. 继承特点：

•                             java中类只能够单继承，不能多继承，可以多层继承

                                       class Yy extends Object {}

                                       class Fu extends Yy{}

                                       class Zi extends Fu {}

                              所有的类都直接或者间接的继承了 Object类，Object类称为祖宗类

• 1. 继承的注意事项：

•                             1，使用关键字 extends 让类与类之间 产生继承关系

                              2, 父类私有的成员，子类不能继承，因为根本看不到

                              3，不能为了继承某个功能而随意进行继承操作， 必须要符合 is a 的关系

                                       苹果 is a 水果

                                       男人 is a 人

                                       狗   is a 人 ， 这种情况就不能继承了

• 1. 继承中的成员变量关系：

•                             不同名的变量：

                                       子类直接继承使用

                              同名的变量：

  默认访问的是子类自己的成员变量, 想访问父类中的同名变量，请使用 super.成员变量;

• 1. 继承中的成员方法关系：

• 不同名的方法：

  子类直接继承使用

  同名的方法：

  默认访问的是子类自己的成员方法，想访问父类中的同名方法，请使用 super.成员方法();

• 1. super:用来表示当前对象中包含的父类对象空间的引用

• 调用父类的成员变量：

  super.成员变量;

                              调用方法的成员方法:

  super.成员方法();

• 1. 方法重写(override)：指 在子父类中，出现了方法声明相同的情况，也叫做方法覆盖，方法复写
     1. 方法重写的注意事项：
• 子类的方法声明要与父类相同

• 2, 子类要重写方法的方法，方法的权限修饰符不能比父类的更低

• 1. 3, 父类私有的方法，子类不能够进行方法重写
  2. 方法重载(overload)：指 在同一个类中，多个方法名称相同，它们的参数列表不同(个数不同，数据类型不同)
• 抽象
  1. 抽象方法： 方法只有声明部分，没有方法体
  2. 抽象类： 包含抽象方法的类，一定是抽象类

•       使用 abstract 修饰的类，是抽象类

• 1. 抽象类的特点：     

•     1，抽象类与抽象方法都必须使用 abstract来修饰       

          2，抽象类不能直接创建对象

          3，抽象类中可以有抽象方法，也可以没有抽象方法

          4，抽象类的子类

              a，实现了抽象方法的具体类

              b，抽象类

• 1. 抽象类面试题：

•         1，抽象类中是否可以没有抽象方法？如果可以，那么，该类还定义成抽象类有意义吗？为什么？

      可以没有抽象方法，有意义，不会让其他人直接创建该类对象

目录

前言

一、什么是继承？

二、继承的实现

三、抽象类及方法

四、抽象方法的具体实现

总结

前言

      java是面向对象的，为了更方便的实现类与类之间的共性，从而产生了继承，把这些共性可以放在一个类中就可产生一个父类，可供有这些共性的子类来使用。而继承中父类中总会有哪些不需要具体实现的方法，而这些方法不用具体实现的话呢，我们就可以来使用抽象类来充当这个类，从而使得继承更加方便使用！！

一、什么是继承？

继承就是抽取类与类之间的共性，通过关键字extends进行处理的，方便了代码的重复使用。继承是会产生子类与父类的，而java中所有类的父类都可以是Object，而其他类都是Object的派生类！

二、继承的实现

 首先我需要先把继承里面的一些关键字来进行介绍，继承最重要的就是extends了，继承就是通过这个关键字来进行处理的，形如（class B extends A）其中A就是B 的父类而B就是子类了。其次父类当中是可以有构造方法的，如果没有的话系统也会默认有无参数的构造方法的，在子类中需要调用父类的构造方法是就需要使用到super这个关键字了，super只能出现在构造方法当中，且只能出现在第一行这是比较特殊的。最后如果一个类不想被继承的话你可以使用final来进行修饰，这样这个类就不会被继承了，下面是具体的代码：

final class A{//一个类不想被继承可设置为final修饰  final 修饰属性 就是常量了

}
class Animal{
    public String name;//当子类变量未赋值的时候 如果同名的 优先访问自己的 除非super来引用
    public int age;//子类里面只能访问公共类型的 
    private int count;//子类不能访问 私有类型的
    protected String sex;//protected保证其他类继承时可以使用  用public 在哪都可以使用
    public void eat(){
        System.out.println(name + "正在吃");
    }
    Animal(String name,int age){//构造方法
        this.name = name;
    }
}
class Dog extends Animal{//继承（Dog Brid 都是子类 或者派生类  Animal 是父类 基类或超类）
    public Dog(String name,int age){
        super(name,age);//显示调用构造方法
    }
    @Override
    public void eat(){
        System.out.println(name + "正在大口吃");
    }
}
class Brid extends Animal{//java当中是单继承 不能多继承  子类构造同时要帮助父类来进行构造
//super()；调用父类的构造方法   super不能出现在静态方法中  super:子类调用父类的
//super.fun（）调用父类的普通方法
//super.data调用父类的成员属性
    public String wing;
    public Brid(String name,int age,String wing){
        super(name,age);//显示调用构造方法  super只能在当前构造方法中  且只能在第一行
        this.wing = wing;
    }
    public void fly(){
        System.out.println(name + "正在飞");
    }

}

public class Test {
    public static void func(Animal animal) {

    }

    public static void main(String[] args) {
        Dog dog = new Dog("huahua", 2);
        System.out.println(dog.name);
        dog.eat();
        System.out.println(dog.sex);
        
       
        }
    }
}

三、抽象类及方法

在父类中如果出现一些不用具体实现的方法时，我们可以把这个方法设为抽象的从而它就可以不用具体实现而被子类使用了，这个类也用设置为抽象类的了，都通过关键字abstract来进行处理。抽象类就是专门用来继承的！

下面是一些抽象方法需要注意的地方：

1、包含抽象方法的类叫做抽象类

2、一个没有具体实现的方法 被abstract修饰

3、抽象类是不可以被实例化的（new）

4、因为不能被实例化 所有只能被继承

5、抽象类当中也可以包含和普通类一样的成员和方法

6、普通类要继承抽象类 必须重写抽象类中的所有的抽象方法

7、抽象类最大的作用就是被继承

8、抽象类A继承了抽象类B 那么抽象类 A可以不用重写 抽象类B的抽象方法

9、类C继承了抽象类A 而A抽象了抽象类B 那么类C必须重写抽象类A和抽象类B中的所有方法

四、抽象方法的具体实现

abstract class Shape { // 抽象类抽象方法都不能被final修饰
    public abstract void draw() ;//抽象方法  不能是private的
}
class Rect extends  Shape{
    @Override
    public void draw() {//一定要重写  否则会报错（继承抽象类）
        System.out.println("♦");
    }
}
abstract class A extends Shape{
    public  abstract  void func();
}
public class Test {
    public static void drawMap(Shape shape){
        shape.draw();
    }
    public static void main(String[] args) {

        Shape shape = new Rect();//可以new成子类对象
        //Shape shape = new Shape() ;不能实例化
        drawMap(shape);


    }
}

总结

        以上就是关于继承和抽象的描述以及实现了，其中也有写的不好的地方，也希望可以理解一下！！这其中有关于重写和多态的相关知识，后续我也会详细介绍的！！