2023/7/03

今天学习了Java中的inal，多态抽象类和接口

final相当于C++中的const，对于用final声明的变量，一旦被设定，就不能改变改变量的值，一对象的引用被final修饰后，他就只能恒定指向一个对象无法使其指向另一个对象。

在父类中被final修饰的方法不能在子类中被隐藏，被final修饰的类是不能被继承的，该类中所有的方法都被隐式设定为final方法，但是成员变量可以被定义为final或非final形式。

package final关键字;

public class 变量 {
    final static double PI=3.1415926;
    public static void main(String[] args)
    {
        System.out.println(PI);
        //PI=3;被final修饰后将无法改变变量的值
        final 变量 a=new 变量();
        //a=new 变量();被对象的引用被final修饰后也无法改变其指向另一个变量
        final int b[]=new int[3];
        //b[]=new int[3];数组也可以看成一个对象来引用所以这里也是会报错的
    }
    final void show()
    {
        System.out.println("变量");
    }
    static void show1()
    {
        System.out.println("变量1");
    }
    private void show2()
    {
        System.out.println("变量3");
    }
}

package final关键字;

public class 变量 {
    final static double PI=3.1415926;
    /*public static void main(String[] args)
    {
        System.out.println(PI);
        //PI=3;被final修饰后将无法改变变量的值
        final 变量 a=new 变量();
        //a=new 变量();被对象的引用被final修饰后也无法改变其指向另一个变量
        final int b[]=new int[3];
        //b[]=new int[3];数组也可以看成一个对象来引用所以这里也是会报错的
    }*/
    final void show()
    {
        System.out.println("变量");
    }
    static void show1()
    {
        System.out.println("变量1");
    }
    private void show2()
    {
        System.out.println("变量3");
    }
}

package final关键字;

final public class 方法 extends 变量
{
    public int f=3;
    public static void main(String[] args)
    {
        方法 a=new 方法();
        a.show1();
        a.show2();
    }
    /*final void show()
    {
        System.out.println("方法");
    }
    被final定义的方法不能被覆盖或者隐藏，在父类定义的方法在子类中不能再定义修改该种方法
    */
    static void show1()//没有final修饰所以可以覆盖或者修改，注意：父类一个静态的方法不能在子类被修改为非动态，反之也是
    {
        System.out.println("变量2");
    }
    private void show2()//父类种的此方法被定义为私有方法，子类自然无法访问，所以不会出现覆盖的现象，但是private类型发方法隐式被指定为final类型
    {
        System.out.println("变量4");
    }
}

package final关键字;

public class 变量 {
    final static double PI=3.1415926;
    /*public static void main(String[] args)
    {
        System.out.println(PI);
        //PI=3;被final修饰后将无法改变变量的值
        final 变量 a=new 变量();
        //a=new 变量();被对象的引用被final修饰后也无法改变其指向另一个变量
        final int b[]=new int[3];
        //b[]=new int[3];数组也可以看成一个对象来引用所以这里也是会报错的
    }*/
    final void show()
    {
        System.out.println("变量");
    }
    static void show1()
    {
        System.out.println("变量1");
    }
    private void show2()
    {
        System.out.println("变量3");
    }
}

package final关键字;

final public class 方法 extends 变量
{
    public int f=3;
    public static void main(String[] args)
    {
        方法 a=new 方法();
        a.show1();
        a.show2();
    }
    /*final void show()
    {
        System.out.println("方法");
    }
    被final定义的方法不能被覆盖或者隐藏，在父类定义的方法在子类中不能再定义修改该种方法
    */
    static void show1()//没有final修饰所以可以覆盖或者修改，注意：父类一个静态的方法不能在子类被修改为非动态，反之也是
    {
        System.out.println("变量2");
    }
    private void show2()//父类种的此方法被定义为私有方法，子类自然无法访问，所以不会出现覆盖的现象，但是private类型发方法隐式被指定为final类型
    {
        System.out.println("变量4");
    }
}

package final关键字;

public class 类 //extends 方法;final类不被任何类继承并且不允许其他人对此类进行改动
{
    public static void main(String[] args)
    {
        方法 a=new 方法();
        a.f=4;//final类中的成员变量可以被定义为final或者非final类
        System.out.println(a.f);
    }
}

对于多态，就是可以通过向上转型用父类的对象引用子类的对象，在不同的参数时调用不同的对象的同名同参的方法

package 多态;

public class Shape {
    
    public void show()
    {
        System.out.println("打印图形");
    }
}
package 多态;

public class circular extends Shape
{
    public void show()
    {
        System.out.println("打印圆");
    }
}
package 多态;

public class Square extends Shape
{
    public void show()
    {
        System.out.println("打印正方形");
    }
}
package 多态;

public class d {
    public static void main(String[] args)
    {
        show(new Shape());
        show(new Square());
        show(new circular());
        Shape c=new Square();
        c.show();
    }
    public static void show(Shape s)//用父类对象引用子类对象来直接调用当前子类对象对应的方法
    {
        s.show();
    }
    /*
     * 之前向上类型转换中提到的父类对象引用子类对象无法调用子类的方法指的是父类与子类中不同名的方法
     * 也是就是子类的特有方法，但是对于子类和父类都有执行方式不同的方法就会根据父类对象引用的实际对象来调用对应方法
     * 这一点像C++中的虚函数
     */
}

使用abstract关键字定义的抽象类，有抽象方法一定时抽象类，抽象类不一定有抽象方法，抽象类中的非抽象方法和成员可以在子类中正常使用，而抽象方法必须在子类中被重写，否则会报错。抽象类不能实例化抽象类对象，但是可以实例化其子类对象，通过多态方法来调用不同类中的方法，但是调用的方法必须时在多态类中的抽象方法的重写方法。注意:抽象方法不能为private类型

package 抽象类与接口;

public abstract class Abstract {
    abstract void name();
    public int a=3;
}
package 抽象类与接口;

public class father extends Abstract{
    public void name()
    {
        System.out.println("father"+a);
    }
}
package 抽象类与接口;

public class son extends father
{
    public void name()
    {
        System.out.println("son"+a);
    }
}

package 抽象类与接口;

public class haihaihai {
    public static void main(String[]args)
    {
        show(new father());//不能直接创建抽象类，但可以创建非抽象的对象
        show(new son());
        Abstract d=new father();
        d.name();
    }
    static void show(Abstract s)//通过其引用的对象来调用对应的方法
    {
        s.name();
    }
    //像C++中的抽象类和纯虚函数，抽象类子类的方法必须重写，否则会报错
}

最后是接口，接口的使用是为了优化抽象类每个子类都必须重写抽象类中的抽象方法。接口的使用方法和抽象类相似，在实现接口后，该接口后的所有子类都必须重写该接口内的方法。接口中的方法为public abstract类型，所以实现接口的类中重写的方法必须是指明public。可以用接口对象引用类的对象，但是只能用这种方法实现接口中含有的方法的多态。

package 接口;

public class one implements zero,ten
{
    public void show()//必须被定义为public类型
    {
        System.out.println("1");
    }
    public void name() {
        System.out.println("1，10");
    }
}
package 接口;

public interface ten {
    void name();
}
package 接口;

public class three implements zero{
    public void show()
    {
        System.out.println("3");
    }

}
package 接口;

public class two extends one{
    public void show()
    {
        System.out.println("2");
    }
    public void name() {
        System.out.println("1，10");
    }
}
package 接口;

public interface zero {
    void show();
}
package 接口;

public class hahaha {

    public static void main(String[] args) 
    {
        zero a=new one();
        zero b=new two();
        zero c=new three();//可以直接用接口的对象引用类的对象，无论类之间有没有继承关系都可以通过这种方法直接访问该类的该方法
        ten d=new one();
        d.name();//对于多接口，只能访问对应接口的方法
        a.show();
        b.show();
        c.show();
    }

}