Java 面向对象的三大特性之一 继承

继承:

Java是继承的三大特性之一,是Java中实现代码重用的手段之一

将重复的代码抽取到父类中继承的有点或者现实

优点:

方便修改代码 减少代码量

Java中继承的语法:

修饰符 SubClass extends SuperClass{
          (称为子类)             (称为父类)
     //定义类部分
}

 继承通过关键字extends关键字来实现,修饰符if是public ,则该类在整个项目中可见,,若无public修饰,则该类至当前可见,不可以使用private和protected修饰类

总结访问修饰符
访问修饰符       本类      同包      子类       其他
private         √             

默认             √         √

protected       √         √         √

public          √         √         √           √

继承需注意:

子类无法继父类的构造方法,无法继承private修饰符的属性

继承public和protected修饰的属性和方法,无论子类和父类是否在一个包里

 继承默认权限修饰符的属性和方法,但子类和父类必须在同一个包里

如何去快速生成构造
alt+shift+s: 选择构造的模板。

删除当前行 ctrl+D

二:重写和继承关系中的构造方法:

     方法重写需满足:

1：重写方法和被重写方法必须具有相同的方法名

2：重写方法和被重写方法具有相同的参数列表

3：重写方法的返回值类型必须和被重写方法的返回值类型或是其子类

4：重写方法不能缩小，重写方法的访问权限，

super代表当前对象的直接类型的默认引用   

super必须出现子类子类方法（和构造方法）

可以访问父类的成员 父类方法和父类属性

访问权限的限制 无法访问private

super
super()父类的构造
super.父类的属性 或者方法 。必须是非私有的(protected,public)

2.子类重写父类的方法
在Java中，实现多态的条件是非常简单的。
父类（普通类）
方法（普通方法）

子类 extends 父类
方法(普通方法 ----->和父类某个方法同名)

结论：
父类 父类对象=new 子类对象();
父类对象.方法名称()(父子都有) 一定打印出子类方法体内容

三：抽象类和抽象类的特点：

1：修饰符：abstract

2：抽象类不能被实例化，抽象类中没有一个或者多个抽象方法，甚至全部方法都可以是抽象方法

3：抽象方法只有方法声明，没有方法实现，有抽象 方法的类必须声明为抽象类，子类必须重写所有的抽象方法才能实例化，否则子类还是一个抽象类

抽象类和抽象方法的注意事项：

案例：实现不同宠物  吃东西方法
    public abstract class Pet{
    
      public abstract void eat();
    }


    public class Cat extends Pet{
      @Override
      public void eat(){
        syso("dog Eat");
      }
    }

  public class Penguin extends Pet{
      @Override
      public void eat(){
        syso("Penguin  Eat fish");
      }
    }
 
 Pet[] pets=new Pet[2];

 Cat cat=new Cat();

 Penguin penguin=new Penguin();

 pets[0]=cat;
 pets[1]=penguin;
  
 for(Pet pet:pets){
   pet.eat();            子类重写父类的eat方法 多态的体现
 }

抽象类和抽象方法的注意事项
1.抽象类中可以有抽象方法，也可以有非抽象方法

2.抽象方法中没有方法体，直接以分号结束

3.抽象方法必须在子类中重写，除非子类本身也是一个抽象类

4.如果用Abstract修饰，那么该类就是抽象类

5.抽象类不能被实例化

6.抽象类不能是静态类

7.抽象类可以有构造

8.抽象方法只能出现在抽象类中

9.抽象方法只是用来约束子类方法行为的

四： final注意事项：

final修饰属性，方法，类

final修饰属性：不能再次赋值
final修饰方法： 方法不能被重写
final修饰类,类不能被继承

public static final String NAME="xxxx"; //常量：不允许修改值

1：final和abstract是功能相反的两个关键字:

2：abstract 可以用来修饰类和方法，不能用来修饰属性和构造方法。final可以用来修饰类，方法和属性，不能修饰构造方法

3：使用final修饰引用型变量时，变量的值是固定不变的。而变量所指向的对象的属性值是可变得

4：

       abstract 和private同时修饰一个方法

       abstract 和static同时修饰一个方法 

       abstract 和final同时修饰一个方法或者类

继承关系下子类构造的执行过程
解析：
1.从Main---->子类构造不进入方法体

2.从子类构造------>父类构造

3.执行父类构造 ，创建了父类对象

4.回到子类构造，执行构造体

5.再回到Main。创建出对象

继承下构造方法的执行过程

父类静态块中方法----子类静态块中方法----父类的非方法代码块（单一{//内容}代码块）---
父类的构造方法---子类的非方法代码块（单一{//内容}代码块）---子类的构造方法

可以用构造方法为属性赋值

当我们实例化子类无参构造时父类没有自定义构造 系统会自动分配一个无参构造

实例化子类对象默认会先执行父类的构造，在执行子类的构造

super();默认调用父类的无参数构造
注意细节：必须是子类中在构造方法的第一条语句

（无参构造会默认调用）

super（参数列表）；调用父类中的有参构造
使用super(参数列表);重复调用父类中的有参构造，默认直接调用父类中的有参数构造，而不会调用父类中的无参数构造

注意：
实例化子类对象时，子类相应的构造，第一行调用父类的哪个构造，就执行哪一个父类构造，，如果没有声明父类构造，默认皆父类的无参构造

 实例讲解：

学生类
package Student;

public class Student1 {
    private String name;

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getAge() {
        return Age;
    }

    public void setAge(int age) {
        if (age >= 16) {
            System.out.println("输入正确");
        } else {
            System.out.println("输入错误");
            
        }

        Age = age;
    }

    private int Age;

    public void print() {
        System.out.println("我的名字是:" + this.name + ",年龄是：" + this.Age + "。");
    }
}

学生的测试类
package Student;

public class StudentTest {

    public static void main(String[] args) {
        // TODO Auto-generated method stub

        Student1 stu =new Student1();
        stu.setAge(1);
        stu.setName("所期望的");
        stu.print();
        
    }    

}

学生1类
package Student1;

public class Student2 {
        
        private String name;
        public String getName() {
            return name;
        }
        public void setName(String name) {
            this.name = name;
        }
        public int getAge() {
            return Age;
        }
        public void setAge(int age) {
            Age = age;
        }
        public String getSex() {
            return sex;
        }
        public void setSex(String sex) {
            this.sex = sex;
        }
        public String getSubject() {
            return subject;
        }
        public void setSubject(String subject) {
            this.subject = subject;
        }
        private int Age;
        private String sex;
        private String subject;
        
        public void println() {
            System.out.println("我的名字是:" + this.name + ",年龄是：" 
        + this.Age + ",性别是:"+this.sex+",我的学科是:"+this.subject);
        }
        
         /*
            * 两个参数的构造函数
            */
           public Student2(String name,int Age){
               this.name=name;
               this.Age =Age;
               this.subject="ACCP";
               this.sex="男";
           }
           public Student2(String name,int Age,String subject,String sex){
               this.name=name;
               this.Age =Age;
               this.subject=subject;
               this.sex=sex;
              
              
           }
           
}

学生1测试类
package Student1;

import Student.Student1;

public class StudentText1 {

    public static void main(String[] args) {
        // TODO Auto-generated method stub

        Student2 stu =new Student2("全球",11,"男","ACCP");
        Student2 stu1 =new Student2("钱钱钱",11);
        stu1.println();
//        stu.setAge(1);
//        stu.setName("哈哈");
//        stu.setSex("男");
//        stu.setSubject("java");
        stu.println();
    }

}