java抽象类

抽象类

一,抽象类

1.为什么要使用抽象类

当编写一个类时，常常会为该类定义一些方法，这些方法用以描述该类的行为特征，也就是说通过这些方法能够完成一个具体的功能，那么这些方法都有具体的方法体。但在某些情况下，某个父类只是知道其子类应该包含怎样的方法，但无法准确地知道这些子类如何实现这些方法，在此情况下我们就可以使用抽象类实现 。也就是说：抽象类约束了子类必须有的方法，而并不关注子类是如何实现的

2.什么是抽象类

很多具有相同特征和行为的对象可以抽取为一个类，很多具有相同特征和行为的类可以抽取成一个抽象类 声明方法的存在而不去实现它的类被叫做抽象类,由abstract修饰的类叫抽象类 抽象类的作用就是 做继承用的,不能用于实例化对象,方法就是用来重写的

3.使用抽象类

 

package com.sk;
​
/**
 * ClassName: Pet <br/>
 * Description: <br/>
 * date: 2021/12/2 9:15<br/>
 *
 * @author 斑马<br />
 */
public abstract class Pet {
    //由 abstract 修饰的类:抽象类
    //抽象类可以有:属性,普通方法,构造方法
    private String name;
    private int heath;
    private int love;
    public Pet(String name, int heath, int love) {
        this.name = name;
        this.heath = heath;
        this.love = love;
    }
    /**显示自己的信息
     * 抽象方法:由abstract修饰的方法
     * 只有方法名,没有方法体的方法
     *Abstract methods cannot have a body
     * 抽象方法在子类中必须重写(除非子类也具有抽象性)
     * */
    public abstract void show();
    //普通的方法,无法要求子类必须重写
    @Override
    public String toString() {
        return "Pet{" +
                "name='" + name + '\'' +
                ", heath=" + heath +
                ", love=" + love +
                '}';
    }
​
    public String getName() {
        return name;
    }
​
    public void setName(String name) {
        this.name = name;
    }
​
    public int getHeath() {
        return heath;
    }
​
    public void setHeath(int heath) {
        this.heath = heath;
    }
​
    public int getLove() {
        return love;
    }
​
    public void setLove(int love) {
        this.love = love;
    }
}

​

package com.sk;
​
/**
 * ClassName: Dog <br/>
 * Description: <br/>
 * date: 2021/12/2 9:30<br/>
 *
 * @author 斑马<br />
 */
public class Dog extends Pet{
    private String strain;
    public Dog(String name, int heath, int love, String strain) {
        super(name, heath, love);
        this.strain = strain;
    }
    //子类必须重写父类(抽象类)中的抽象方法
    @Override
    public void show() {
        System.out.println("name:"+getName()+"\theath:"+getHeath()
                +"\tlove:"+getLove()+"\tstrain:"+strain);
    }
​
    public String getStrain() {
        return strain;
    }
​
    public void setStrain(String strain) {
        this.strain = strain;
    }
}
​
package com.sk;
​
/**
 * ClassName: PetTest <br/>
 * Description: <br/>
 * date: 2021/12/2 9:51<br/>
 *
 * @author 斑马<br />
 */
public class PetTest {
    public static void main(String[] args) {
        //'Pet' is abstract; cannot be instantiated
        //抽象类不能实例化对象  (不能new对象)
        //Pet p=new Pet();
        //只能实例化其子类
        Dog d=new Dog("历而后",100,80,"土狗");
        d.show();
    }
}
​

4.抽象类的应用场合

 

小结

抽象类有哪些规则？ 抽象类必须使用abstract关键字修饰 抽象类不能被实例化，即无法使用new关键字来创建对象 抽象类中可以有0~多个抽象方法 抽象类中的抽象方法必须在子类中实现 抽象类中可以包含属性、方法（抽象方法和普通方法）、构造方法等内容 抽象方法有哪些规则？ 抽象方法必须使用abstract关键字修饰 非抽象类必须重写父类的所有抽象方法 构造方法和static方法是不能被抽象的 抽象方法没有方法体

二,final

1.final修饰变量

final修饰的变量是常量:值不能被改变

package com.sk;
​
/**
 * ClassName: testDome01 <br/>
 * Description: <br/>
 * date: 2021/12/2 8:12<br/>
 *
 * @author 斑马<br />
 */
public class Dome01 {
    public static void main(String[] args) {
        //final修饰的变量是常量:值不可被改变
        final int weekDay=7;
        System.out.println(weekDay);
        //值不可被改变
        //weekDay+=1;
        final double Pi;
        Pi=3.14;
        //常量只能赋值一次
        //Pi=3.14159;
        //常量都是有特殊含义的字段,经常使用的字段,值是固定的
        double aa=Pi*2;
    }
}
​

2.final修饰方法

package com.sk;
​
/**
 * ClassName: Dome02 <br/>
 * Description: <br/>
 * date: 2021/12/2 8:22<br/>
 *
 * @author 斑马<br />
 */
public class Dome02 {
    public void a(){
​
    }
    /*final修饰的方法:不能被重写*/
    public final void b(){
​
    }
}
class A extends Dome02{
    @Override
    public void a() {
        super.a();
    }
    //'b()' cannot override 'b()' in 'com.sk.Dome02'; overridden method is final
    //public void b(){ }
}

3.final修饰类

package com.sk;
​
/**
 * ClassName: Dome02 <br/>
 * Description: <br/>
 * date: 2021/12/2 8:22<br/>
 *
 * @author 斑马<br />
 */
​
public final class Dome02 {
    public void a(){
​
    }
    /*final修饰的方法:不能被重写*/
    public final void b(){
​
    }
}
//final修饰的类不能被继承,称这种类为:最终类
class A extends Dome02{
    //'b()' cannot override 'b()' in 'com.sk.Dome02'; overridden method is final
    //public void b(){ }
}
public final class String
    implements java.io.Serializable, Comparable<String>, CharSequence {}
​

String类是最终类,无法被继承

4.常量命名规则

有意义 均大写 长度不宜太长

什么时候使用常量？

不随意修改,多处引用,其值有特定含义