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();
    }

}

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

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