2021-7-20 第二章 对象和封装

第二章 对象和封装

继承

1. 继承是通过extends关键词来实现的。

2. 继承是面向对象对象的三大特性之一，是java中实现代码重要性的重要手段之一。

3. java中只支持单继承。

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

5. 继承默认修饰符修饰的属性和方法，单子类和父类必须在同一个包里。

6. 无法继承private修饰的属性和方法。

7. 无法继承父类的构造方法。

public class Dog extends Pet {
    private String strain;
    public  Dog(String name,String strain) {
        super(name);
        this.strain=strain;
    }
    public String getStrain() {
        return strain;
    }

重写

1. 重写的方法名和被重写的方法名必须相同.

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

3. 重写方法的返回值类型必须必须和被重写方法的返回值类型相同或是其子类（double是int子类）.

4. 重写方法不能缩小被重写方法的访问权限.

public class Dog extends Pet {
    private String strain;
    public  Dog(String name,String strain) {
        super(name);
        this.strain=strain;
    }
    public String getStrain() {
        return strain;
    }
    public void print() {
        super.print();
        System.out.println("我是一只"+strain);
    }
}

super 关键词

1. super必须出现在子类（子类的方法或构造方法）中.

2. 可以访问父类的成员，如父类的属性，方法，构造方法.

3. 访问权限限制，无法通过super访问private成员.

4. super.name;//访问父类属性.

5. super.print();//访问父类方法.

6. super.(name);//访问父类构造方法.

7. 在构造方法中第一行.

package javaZYHJ;
/*
 * 实例8
 */
​
public class Persion {
 String name;
 
   public Persion(){
  System.out.println("execute Person()");
 }
        
 public Persion(String name) {
  this.name=name;
  System.out.println("");
 }
 
  
 public static void main(String[] args) {
  // TODO Auto-generated method stub
  Post post = null;
  post=new Post();
  
  System.out.println();
  post=new Post("柚子","北京大学","王老师");
 }
 
}
​
​
//2
​
class Student extends Persion{
 String scholl;
 
 public  Student() {
  System.out.println("execute student()");
 }
 
 public Student(String name,String school) {
  super(name);
  this.scholl =school ;
  System.out.println("execute Person(name，school)");
 }
 
}
​
//3
class Post extends Student{
 String guide ;
 
 public Post() {
  System.out.println("execute student()");
 }
 
 public Post(String name,String school,String guide) {
  super(name,school);
  this.guide=guide
  System.out.println("execute Person(name，school,guide)");
 }
}

抽象类和抽象方法

1. 抽象类和抽象方法都通过abstract关键词修饰.

2. 抽象类不能实例化，抽象类中可以没有，有一个或者多个

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

限制类不能实例化.

public abstract class Pet {
    private String name ="无名式";//名称默认
    private int health =100;//健康值，默认100
    private int love =0;//亲密度
    /**
     * 无参构造方法
     */
    public Pet() {
        this.health=95;
        System.out.println("执行了无参构造方法！");
    }
    public Pet(String name) {
        this.name=name;
    }
    public String getName() {
        return name;
    }
    public void print() {
        System.out.println("我的名字叫"+name+"健康值是"+health+"和主人的亲密值是"+love);
    }
}
public class Text {
​
    public static void main(String[] args) {
        // TODO Auto-generated method stub
        Pet pet=new Pet();
        //报错，abstract修饰类无法实例化   
        pet.print();
        Dog dog=new Dog("牛牛", "雪纳瑞");
        dog.print();
        Penguin penguin=new Penguin("小Q", "Q仔");
        penguin.print();
    }
​
}

final修饰符

1. final修饰类，不再有子类.

2. final修饰方法，方法不再被子类重写.

3. final修饰属性，变量将变为常量，不再被修改该.

4. final不能与abstract同时修饰一个类或一个方法.