Java（day08）重写、final、static

方法的重写

要求：:两同两小一大

两同:方法名 参数列表 要完全一致

两小:子类返回值类型小于等于父类的返回值类型(注意此处说的是继承关系,不是值大小)
子类抛出异常小于等于父类方法抛出异常

一大:子类方法的修饰符权限要大于等于父类被重写方法的修饰符权限

总结：

1.如果父类的方法的返回值类型与子类方法的返回值类型一样，肯定没错

2.如果父类的返回值类型为：8大基本类型/String/void,子类重写时应该保持一致

3.如果父类方法的返回值类型是其他引用类型，子类方法;父类返回值类型或者两者相同

package cn.tedu.oop;
/*方法重写之返回值要求*/
public class TestMethod {
    public static void main(String[] args) {
    }
}
class Fu{
    public int eat(){
        return 666;
    }
    public String play(){
        return "中午好";
    }
    public Animal clean(){
        Animal a=new Animal();
        return a;
    }
}
class Zi extends Fu{
    public int eat(){
        return 666;
    }
    public String play(){
        return "中午好";
    }
    public Animal clean(){
        Animal a=new Animal();
        return a;
    }
}
class Animal{}
class Cat extends Animal{}

package cn.tedu.oop;
/*方法重写之返回值要求*/
public class TestMethod {
    public static void main(String[] args) {
    }
}
class Fu{
    public int eat(){
        return 666;
    }
    public String play(){
        return "中午好";
    }
    public Animal clean(){
        Animal a=new Animal();
        return a;
    }
}
class Zi extends Fu{
    public int eat(){
        return 666;
    }
    public String play(){
        return "中午好";
    }
    public Cat clean(){
        Cat c =new Cat();
        return c;
    }
}
class Animal{}
class Cat extends Animal{}

final

final可以修饰类，但是被final修饰的类不能继承

final可以用来修饰方法，但是被final修饰的方法不能重写

被final修饰的是常量，常量的值不可以被修改，且常量的名字必须全大写，单词与单词之间用-分割

static

static可以修饰成员变量

static可以修饰方法

被static修饰的资源统称为静态资源，静态资源是随着类加载而加载到内存中，比对象优先进入内存，所以静态资源可以直接通过类名调用

package cn.tedu.oop2;
/*本类用作静态static的入门案例*/
public class TestStatic {
    public static void main(String[] args) {
        Fruit.kind="红富士";
        Fruit.weight=100;
        Fruit.clean();
        System.out.println(Fruit.kind);
        System.out.println(Fruit.weight);
        Fruit f=new Fruit();
        f.grow();
        f.clean();
    }
}
class Fruit{
    static String kind;
    static double weight;
    public static void clean(){
        System.out.println("洗水果");
    }
    public void grow(){
        System.out.println("这个果子长的一看就很好吃~");
    }
}
运行结果：
洗水果
红富士
100.0
这个果子长的一看就很好吃~

静态资源在内存中只有一份，而且会被全局所有对象共享所以不管我们使用哪种方式修改静态变量的值，使用任何方式查看都是静态变量那个刚刚被修改的值

package cn.tedu.oop2;

import javax.xml.stream.XMLOutputFactory;

/*本类用作静态static的入门案例*/
public class TestStatic {
    public static void main(String[] args) {
        Fruit f=new Fruit();
        Fruit f2=new Fruit();
        Fruit.kind="红富士";
        System.out.println(Fruit.kind);
        System.out.println(f.kind);
        System.out.println(f2.kind);
        f.kind="香蕉";
        System.out.println(Fruit.kind);
        System.out.println(f.kind);
        System.out.println(f2.kind);
    }
}
class Fruit{
    static String kind;
    static double weight;
    double price;
    public static void clean(){
        System.out.println("洗水果");
    }
    public void grow(){
        System.out.println("这个果子长的一看就很好吃~");
    }
}
执行结果：
红富士
红富士
红富士
香蕉
香蕉
香蕉

普通资源可以调用静态资源;但是静态资源不可以调用普通资源

package cn.tedu.oop2;
/*本类用来测试静态的调用关系*/
public class TestStatic2 {
    public static void main(String[] args) {
        
    }
}
class Teacher{
    String name;
    public void teach(){
        System.out.println("正在授课中");
        System.out.println(age);
        ready();
    }
    static int age;
    public static void ready(){
        System.out.println("正在备课中");
    }
    public static void eat(){
        System.out.println("正在干饭中");
    }
}

 静态不能重写

package cn.tedu.oop;

import javax.sound.midi.Soundbank;

//本类用于测试多态成员的使用情况
public class TestDemo2 {
    public static void main(String[] args) {
        Animal2.play();
    }
}
class Animal2{
    int sum=10;
    public void eat(){
        System.out.println("吃啥都行");
    }
    public static void play(){
        System.out.println("玩啥都行");
    }
}
class Dog2 extends Animal2{
    int sum=20;
    public void eat(){
        System.out.println("狗吃肉包子");
    }
    public static void play(){
        System.out.println("小狗玩飞盘");
    }
}
执行结果：
玩啥都行

静态代码块：static{}

位置：类里方法外

执行时机：静态代码块属于静态资源，随着类的加载而加载，优先于对象加载并且只加载一次

作用：用于加载需要第一时间加载的资源，并且只加载一次资源，常用来初始化

package cn.tedu.oop2;
/*测试静态代码块*/
public class TestStatic3 {
    public static void main(String[] args) {
        Persion P=new Persion();
        Persion P1=new Persion();
    }
}
class Persion{
    static {
        System.out.println("我是静态代码块");
    }
    {
        System.out.println("我是构造代码块");
    }
    public void play(){
        System.out.println("我是一个普通方法");
        {
            System.out.println("我是一个局部代码块");
        }
    }
}
执行结果：
我是静态代码块
我是构造代码块
我是构造代码块

静态代码块>mian方法>构造代码块>构造方法