Java第十三天

一：final 再次总结：
1.final修饰的变量？
final修饰的局部变量，一旦赋值不能重新赋值。

public class Main {
    public static void main(String[] args) {
        final int a=100;
        System.out.println(a);//100
        //final修饰的局部变量只能赋值一次，无法重新赋值
        /*a=200;
        System.out.println(a);
        */
        
        final Animal anm=new Animal(999);
        System.out.println(anm.getVal());//999
        //final修饰的引用，无法更改引用方向，但可以修改数据的值
        /*
        anm = new Animal();
        System.out.println(anm.getVal());
        final Animal anm=new Animal(999);
         */
        anm.setVal(1000);
        System.out.println(anm.getVal());//1000
    }
}
class  Animal{
    private int val;
    //构造方法
    public Animal(){}
    public Animal(int val){
        this.val=val;
    }
    //setter和getter
    public int getVal() {
        return val;
    }
    public void setVal(int val) {
        this.val = val;
    }
}

2.final修饰的方法？
final修饰的方法无法被覆盖，被重写。

public class Main {
    public static void main(String[] args) {
        Animal anm=new Cat();
        anm.dosome();
    }
}
class Animal{
    //final修饰的方法无法被覆盖，被重写。
    /*
    public final void dosome(){
        System.out.println("动物");
    }
    */
    public void dosome(){
        System.out.println("动物");
    }
}
class Cat extends Animal{
    public void dosome(){
        System.out.println("猫");
    }
}

3.final修饰的类？
final修饰的类无法继承。

public class Main {
    public static void main(String[] args) {
        Animal anm=new Cat();
        anm.dosome();
    }
}
//final修饰的类，无法继承
/*
class final Animal{
    public void dosome(){
        System.out.println("动物");
    }
}
 */
class Animal{
public void dosome(){
        System.out.println("动物");
    }
}
class Cat extends Animal{
    public void dosome(){
        System.out.println("猫");
    }
}

4.总结：final修饰的变量，只能赋一次值。

二. 关于java语言中的抽象类：
1.什么是抽象类？
1）类与类之间具有共同特征，将这些共同特征提取出来，形成的就是抽象类。
2）类本身是不存在的，所以抽象类无法创建对象，即无法实例化。
2.抽象类输入什么类型？
抽象类也属于引用数据类型
3.抽象类怎么定义？
语法：
[修饰符列表] abstract class 类名{
类体;
}
4.抽象类是无法实例化的，无法创建对象的，所以抽象类是用来被子类继承的。
5.final和abstract不能联合使用，这两个关键字是对立的。
6.抽象类的子类可以是抽象类。
7.抽象类虽无法实例化，但是抽象类有构造方法，这个构造方法是供子类使用的。
8.抽象类中不一定有抽象方法，抽象方法一定在抽象类中。
9.抽象方法的定义？
public abstract void dosome();
抽象方法的特点：
1）没有方法体，以分号结尾
2）前面修饰符列表中有abstract关键字
10.一个非抽象的类，继承抽象类，必须将抽象类中的抽象方法进行覆盖/重写/实现

public class Main {
    public static void main(String[] args) {
        //抽象类是无法实例化的，无法创建对象，所以抽象类是用来被子类继承的
        /*
        Animal anm=new Animal();
        */
        Animal c=new Cat();
        c.dosome();

    }
}
//final和abstract不能共存，两个关键字对立关系
//java: 非法的修饰符组合: abstract和final
/*
final abstract class Animal{
    public abstract void dosome();
}
*/

//抽象类的定义
abstract class Animal{
    //抽象类虽无法实例化，但是抽象类有构造方法，这个构造方法是供子类使用的
    public Animal(){
        System.out.println("抽象类");
    }
    //抽象方法的定义
    //抽象类中不一定有抽象方法，抽象方法一定在抽象类中
    public abstract void dosome();
}
//继承
class Cat extends Animal{
    public Cat(){
        super();
        System.out.println("继承抽象类的Cat类的构造方法");
    }
    //继承抽象类的时候，要进行方法覆盖
    public void dosome(){
        System.out.println("覆盖抽象类的方法");
    }
}
//抽象类的子类可以是抽象类
/*
abstract class Dog extends Animal{
    public abstract void dosome();
}
 */