Java程序设计基础------类与对象（四）

这是类与对象的第四篇博客，主要讲一下final类和抽象类。一起来看看吧！

什么是最终类与最终方法？有什么作用？

如果一个类被final修饰符修饰，说明这个类就是最终类，不能被继承。

如果一个方法被final修饰符修饰，说明这个方法就是最终方法，不能被子类重写。

主要作用增加代码的安全性

什么是抽象类和抽象类的方法，使用时应注意什么问题？

如果一个类被abstract修饰符修饰，说明他就是抽象类，抽象类专门用来当作父类的。

抽象类的方法分为两种：一种是普通的方法，一种是被abstract修饰的抽象方法，抽象类不一定包含抽象方法，但是含有抽象方法的类一定是抽象类。

抽象类本身不具有实际功能，只能用于派生其他子类，并且定义为抽象的方法必须在子类中被重写，所以一个抽象类就不能用new创造一个实例对象，，必须利用重写的方式实现抽象类中的方法。一个类不能即时抽象类，又是最终类，所以修饰符abstract和final不能在一起用！

final的含义？

1>final是不可改变的意思，当一个变量被定义为final型时，它就成了一个常量且必须初始化；
2>当一个类被定义为final型时，这个类不能被继承；
3>当一个方法被定义为final型时，这个方法可以被继承，但不能再被改写。

注意2和3的区别！！！

抽象类的特点？

1>被abstract修饰，不能被实例化；
2>抽象类可以包含抽象方法；
3>抽象类的子类也可以是抽象类；
4>继承抽象类的非抽象类，必须实现超类中的全部抽象方法。

静态代码块、实例代码块、构造函数的运行顺序

静态代码块最先运行，然后是实例代码块，最后是构造函数。因为静态代码块是属于类的，所以在类加载时就运行了。

方法重写的注意事项有哪些？

1>方法重写只存在于子类和父类（包括直接父类和间接父类）之间，在同一个类中的方法只能被重载，不能被重写。
2>子类方法必须和父类方法具有相同的方法名、参数列表和返回值
3>子类可以定义与父类的类方法同名的类方法，以便在子类中隐藏父类的类方法
4>父类中的类方法不能被子类重写成实例方法，而父类的实例方法也不能被子类隐藏为类方法
5>父类中的private、final修饰的方法不能被重写；子类方法不能缩小父类的访问权限；子类方法不能抛出比父类方法更多的异常。

最终类和最终类的方法实例：

最终类中的方法与变量：

public class Demo_final {
    public static void main(String[] args) {
        Foo f = new Foo ();
        System.out.println(f.I);//可以访问最终类的常量，但是不能修改
        f.show();//调用最终类中的最终方法
    }
}
 final class Foo{
    final static int I = 10;//常量
    final void show(){
        System.out.println("我是一个最终方法");
    }
}

//class Foo1 extends Foo{  报错  原因： 声明为最终类不能在继承了
//
//}

普通类中的变量与方法：

public class Demo_final2 {
    public static void main(String[] args) {
        Woo w = new Woo();
        System.out.println(w.I);
        w.show();
        System.out.println("--------------------------");
        Woo1 s = new Woo1();
      //  s.I = 19;//不能修改
        System.out.println(s.I);
        s.speak();
    }
}
class Woo{
    final static int I = 10;
    final void show(){
        System.out.println("我是普通类中的最终方法");
    }
}
class Woo1 extends Woo{  //可以继承含有最终方法的类
//    void show(){  报错，不能重写父类的最终方法
//
//    }
    public void speak(){
        System.out.println("aaaa");
    }
}

运行结果：

抽象类和抽象类的方法的实例代码

public class Demo_chouxiang {
    public static void main(String[] args) {
//        abstract_Foo s = new abstract_Foo() {
//            @Override
//            void show() {
//
//            }
//
//            @Override
//            void speak() {
//
//            }
//        }
        //不能创建抽象类的实例对象，必须重写其中的抽象方法

        abstract_Foo_Son a = new abstract_Foo_Son();
        a.show();
        a.speak();
    }
}
abstract class abstract_Foo{

    abstract void show();//声明抽象方法  并且后面不能跟大括号！！
    abstract void speak();

}

class abstract_Foo_Son extends abstract_Foo{

    public void show(){
        System.out.println("我会展示");
    }
    public void speak(){
        System.out.println("我会说话");
    }
}

抽象类的继承问题：

package demo_practice;

public class Demo1_abstract {
}

abstract class abstract_Foo1{
    abstract void speak1();
 }

 abstract class abstract_Foo1_Son{
    abstract void read1();
 }
class abstract_Foo_son2 extends abstract_Foo_Son{
    public void speak1(){
        System.out.println("我会说");
    }
    public void read1(){
        System.out.println("我会读");
    }
    
 }

抽象类可以继承抽象类，但是实现类必须实现父类的所有抽象方法！

关于最终类和抽象类的一些知识点就说到这了，有兴趣的可以一起交流啊！！！

Java程序设计基础------类与对象（四）

猜你喜欢