巩固java day02 继承 extends 与 构造器 instructor 稀疏数组

巩固java day02

继承 extends 与 构造器 constructor

package cn.demo.day02;

public class Study {
     public static void main(String[] args){
         Father fa = new Son();
         System.out.println(fa.i);
     }
}

class Father{
    int i = 10;
    public Father(){
        print();
        int i =20;
    }
    public void print(){
        System.out.println("father: "+i);
    }
}

class Son extends Father {
    int i = 30;
    public Son(){
        print();
        int i = 40;
    }

    public void print(){
        System.out.println("son: "+i);
    }
}

/*
son: 0
son: 30
10

此题的特殊之处是在与继承和构造器之上。
1、由于Son类继承了Father类，当new Son()时，会默认先给Father分配空间，于是Father类调用执行无参构造器，但是由于Son类重写了父类的print方法，于是会执行Son类重写了的print方法。然而此时的Son类未被分配空间，i的值为0，输出结果为：0
2、上一步执行完后，Son类会被分配空间，i被赋值为30，执行Son类的无参构造方法，输出结果为：30
3、最后输出的结果比较好理解，因为是对象的上转型，fa只能调用Father父类的变量和方法。结果为：10
*/

重写

• 若子类继承了父类，且重写了父类的方法，那么父类通过上转型调用该方法一定是执行子类重写后的方法。

类变量（使用 static修饰，用类名直接调用）

所有对象共享类变量

如果类中有类变量，当使用new运算符创建多个不同的对象时，分配给这些对象的这个类变量占有相同的一处内存，改变其中一个对象的这个类变量会影响其他对象的这个类变量

类方法（使用 static修饰，用类名直接调用）

使用static修饰的变量和方法都会在字节码加载到内存时就创建的空间，但是实例变量和方法并不会创建空间，只有new之后才会创建空间，因此类方法不可以操作实例变量和方法。

静态代码块

主类的静态块会被最先执行，而且静态块会优先与构造器被执行。其余类的静态块只有在创建的时候才被执行。

public class A1 {
    static {
        System.out.println("我是最先被执行的静态块！");
    }
    public static void main(String[] args) {
        B1 b1 = new B1();
        System.out.println("我在了解静态块的执行顺序！！！");
    }
}

class B1{
    B1() {
        System.out.println("我是无参构造器！！");
    }
    static {
        System.out.println("我是B1的静态块！");
    }

}
/*
我是最先被执行的静态块！
我是B1的静态块！
我是无参构造器！！
我在了解静态块的执行顺序！！！
*/

java2实用教程 第四章编程题答案

public class Test {
    public static void main(String[] args) {
        CPU cpu = new CPU();
        cpu.speed = 2200;
        HardDisk disk = new HardDisk();
        disk.amount = 200;
        PC pc = new PC();
        pc.setCPU(cpu);
        pc.setHardDisk(disk);
        pc.show();
    }
}

public class PC {
    CPU cpu;
    HardDisk HD;
    void setCPU(CPU c){
        this.cpu = c;
    }
    void setHardDisk(HardDisk h){
        this.HD = h;
    }
    void show(){
        System.out.println("cpu的速度："+cpu.speed);
        System.out.println("硬盘的容量："+HD.amount);
    }
}

public class CPU {
    int speed;
    void setSpeed(int m){
        this.speed = m;
    }
    int getSpeed(){
        return this.speed;
    }
}

public class HardDisk {
    int amount;
    void setAmount(int m){
        this.amount = m;
    }
    int getAmount(){
        return this.amount;
    }

}

java2实用教程 第五章编程题答案

public class Application {
    public static void main(String[] args) {
        Simulator simulator = new Simulator();
        simulator.playSound(new Dog());
        simulator.playSound(new cat());
    }
}

public abstract class Animal {
    public abstract void cry();
    public abstract String getAnimal();
}

public class Simulator {
    void playSound(Animal animal){
        animal.cry();
        animal.getAnimal();
    }

}

public class Dog extends  Animal {

    @Override
    public void cry() {
        System.out.println("汪汪汪....");
    }

    @Override
    public String getAnimal() {
        System.out.println("该动物是狗");
        return null;
    }
}

public class cat extends Animal {
    @Override
    public void cry() {
        System.out.println("喵喵喵....");
    }

    @Override
    public String getAnimal() {
        System.out.println("该动物是猫");
        return null;
    }
}

interface 接口

1. 接口体只能是public类型
2. 接口体里面只能是public类型的static常量 ，可允许省略public、final、static（例：public static final int a = 10）
3. 接口体里面的方法必须public类型的抽象方法abstract，允许省略public abstract（ 例：public abstract void Test ( ) { } ）
4. final 不能和 abstract 同时使用

java2实用教程 第六章编程题答案

public class Application {
    public static void main(String[] args) {
        Simulator simulator = new Simulator();
        simulator.playSound(new Dog());
        simulator.playSound(new cat());
    }
}

interface Animal {
    public abstract void cry();
    public abstract String getAnimal();
}

public class Simulator {
    void playSound(Animal animal){
        animal.cry();
        animal.getAnimal();
    }
}

public class Dog implements Animal {

    @Override
    public void cry() {
        System.out.println("汪汪汪....");
    }

    @Override
    public String getAnimal() {
        System.out.println("该动物是狗");
        return null;
    }
}

public class cat implements Animal {
    @Override
    public void cry() {
        System.out.println("喵喵喵....");
    }

    @Override
    public String getAnimal() {
        System.out.println("该动物是猫");
        return null;
    }
}

内部类

class Cry{
    public void cry(){
        System.out.println("大家好！");
    }
}

class EE {
    public static void main(String[] args) {
        Cry hello = new Cry(){
            public void cry(){
                System.out.println("大家好，祝工作顺利！");
            }
        };
        hello.cry();
    }
}
//结果：大家好，祝工作顺利！
/*
因为内部类重写了本类的方法，因此hello.cry();输出的结果为内部类重写后的输出语句。
*/

稀疏数组

• 第一行保存的是原始数组的行列数和有效值有多少个，其余行保存的是各个有效值的行列位置和数值