Java第七课

一、课后作业讲解

public class Shape {
    /**
     * 计算长方形的周长
     * @param rectangle
     * @return
     */
    public int perimeter(Rectangle rectangle) {
        return (rectangle.getLength()+rectangle.getWidth())*2;
    }
    /**
     * 计算正方形的周长
     * @param square
     * @return
     */
    public int perimeter(Square square) {
        return square.getWidth()*4;
    }
}
public class Square {
    /**
     * 边长
     */
    private int width;

    public Square(int width) {
        this.width = width;
    }

    public int getWidth() {
        return width;
    }
}
public class Rectangle {
    /**
     * 长
     */
    private int length;
    /**
     * 宽
     */
    private int width;

    public Rectangle(int length, int width) {
        this.length = length;
        this.width = width;
    }

    public int getLength() {
        return length;
    }

    public int getWidth() {
        return width;
    }
}

二、属性的继承

当父类中的属性不是私有的可以继承到子类中，当子类中有同名的属性时，会覆盖父类的属性，有点像方法的重写

重点：父类的属性可以被继承，但无法覆盖，这个和方法不一样

三、多态

多态是用父类声明的变量指向子类的实现，该变量随着实现的子类不同，对于相同的行为（方法）表现出不同的现象，就是多态

Father有三个子类Son1,Son2,Son3

Father类中的say行为（方法）在三个子类中都被重写，表现不同

Father person = new Son1(); person.say()表现出大声说话

Father person = new Son2(); person.say()表现出小生哼哼

Father person = new Son3(); person.say()表现出抑扬顿挫

多态时，用父类声明的变量只能在父类中获取自身的属性，无法获取子类的属性

虽然person实际上是指向了内存中Son1的对象，但是只能获取父类的属性。

如果父类中的方法在子类中有重写，则用person调用该方法时，实际调用的是子类的方法。

  • 当多态时，子类中的方法可以重写父类中的方法，子类中的属性无法覆盖父类中的属性。当通过父类声明的变量调用属性时，永远获取的时父类中的属性，调用方法时，永远调用的是子类的方法。
  • 多态的优点
  1. 增加了程序的灵活性
  2. 增加了程序的扩展性
public class Party {
    public static void main(String[] args) {
        Party party = new Party();
        party.act(new Yueyunpeng());
        party.act(new Songxiaofeng());
    }

    public void act(Actor actor) {
        actor.say();
    }
}
class Actor{
    protected void say() {
        System.out.println("Actor say");
    }
}
class Yueyunpeng extends Actor{
    @Override
    protected void say() {
        System.out.println("我的天哪");
    }
}
class Dacui extends Actor{
    @Override
    protected void say() {
        System.out.println("好尴尬啊");
    }
}
class Songxiaofeng extends Actor{
    @Override
    protected void say() {
        System.out.println("此时此景我想吟诗一首");
    }
}

四、静态

  • static
  • public static void main(String[] args)
  • 当一个类中有静态的成员时，这个类被加载到JVM中时，会首先初始化静态的成员
public class Student {
    /**
     * 静态的成员
     */
    protected static int num;

    /**
     * 增加学生
     * @param student
     */
    protected static void add(Student student) {
        
    }
}

当Student.class文件加载到JVM中时，JVM会创建一个Class对象（类模板对象），在这个对象中存储了num和add对象（num是一个成员对象，add是一个方法对象）

Student student;当这行代码执行时，JVM就会加载class文件，换句话说，当代码中一旦出现了Student字样，JVM就会加载Student.class文件。

Class在Java中是一个特殊的类，是模板类，它会根据类的实际信息构建出该类的一个模板对象，模板对象中存储着类的成员对象

它会在模板对象中存储静态的成员信息num和add，num = 0;模板对象中分两块区域，一块是静态区域，一块非静态的

当Student类加载到JVM时，此时并没有Student的实例，所以静态是脱离实例存在的，它不属于某个实例，而是属于该类的信息。调用静态成员时，只需要通过类名.调用，不需要实例来调用。

在静态方法中，是无法使用实例信息的，因为在静态方法中，实例还没有创建，先有静态，后有实例。

静态和类的关系，静态属于类的，不属于实例的，静态可以被继承，但无法覆盖。

  1. 静态成员属于类，不属于对象
  2. 静态方法无法访问实例
  3. 静态可以被继承，但无法覆盖

静态的优点： 1.通过类名方便调用，多用于工具类的方法

2.公共资源，不随实例的变化而变化

静态的缺点：1.因为是公共的，从JVM加载到JVM卸载始终占用资源，不会被回收

public class Ticket {
    /**
     * 共有20张票
     */
    private static int num = 20;

    public  void sale() {
        if (num <= 0) {
            System.out.println("票已售罄");
        } else {
            System.out.println("剩余" + --num+"张票");
        }
    }

    public static void main(String[] args) {
        Ticket ticket = new Ticket();
        for (int i=0;i<21;i++) {
            ticket.sale();
        }
    }
}

五、抽象

  • abstract
  • 没有方法体的方法是抽象方法，有抽象方法的类必须是抽象类
  • 抽象类可以没有抽象方法
  • 抽象类无法创建实例，不能new
  • abstract class A{
    abstract void work();
    }
    work是一个抽象方法，这个方法什么都没有做。假设让 A a = new A();
    a.work();为了避免什么都不能做的情况，就不能让抽象类初始化，创建对象。
    抽象类存在的意义是被继承。


软件下载提取码：qwer