正文：

上一篇是《java访问权限和javaObject》，朋友们理解得怎么样？这篇分享的是《Java中final关键字的作用和Java抽象类》。

接下来开始今天的分享：

Java中final关键字的作用

• final修饰字段,在定义时必须显示初始化, 不能被修改, 一般与static同时使用,所有字母都大写,称为final常量
• final修饰方法,不能被覆盖(重写)
• final修饰局部变量, 一旦初始化就不能再修改, 注意final修饰引用类型变量,是指这个变量不能再指向 其他对象 , 可以修改它的字段值
• final修饰方法形参, 在方法体中不能修改final参数的值

package com.bjpowernode.chapter01.demo04.p1;
/**
* 1) final修饰类,表示这个类是最终类, 不能被继承
* 如System类/String类就是使用final修饰的
* 当定义的类不想被别的类继承时, 就可以使用final修饰
* @author Administrator
*
*/
public final class Father {

}

package com.bjpowernode.chapter01.demo04.p2;
/**
* 2) final修饰字段
* final字段必须初始化,要么在定义时赋初值,要么在构造方法中赋初值
* final字段不能重新赋值
* 一般情况下,final修饰字段时, 同时使用static一起修饰, 称为final常量 , 所有字母都大写
* @author Administrator
*
*/
public class Father2 {
int xx;
int yy = 20; 
final int oo = 456; //final字段在定义时显示初始化
final int zz;    //final字段在构造方法中显示初始化
final static double PI = 3.14;    //final常量 
public Father2() {
zz = 121;
}    
public void mm() {
xx = 123;
yy = 202;
//    zz = 789; //he final field Father2.zz cannot be assigned
//    oo = 369;    //final字段不能被重新赋值
}
}

package com.bjpowernode.chapter01.demo04.p3;
/**
* 3) final修饰方法, 不 能被子类重写(覆盖)
* 注意:子类可以继承到final方法, 只是不能重写
* @author Administrator
*
*/
public class Father3 {
public void m1(int xx) {
System.out.println("父类的实例方法,可以子类覆盖");
}    
public final void m2(int x, int y ) {
System.out.println("使用final修饰的方法, 不能被子类重写");
}
}

package com.bjpowernode.chapter01.demo04.p4;
import com.bjpowernode.chapter01.demo03.Book;
/**
* 4) final修饰局部变量
* 一旦初始化完成, 就不能再重新赋值
* @author Administrator
*
*/
public class Test {
public static void main(String[] args) {
//定义局部变量
int x ;
x = 10;
int y = 20; 
//final修饰局部变量
final int z;
z = 30;
final int t = 40;    
//可以给局部变量重新赋值
x = 101;
y = 202;
//    z = 303; //不能给final局部变量重新赋值    
//final修饰引用类型变量
final Book book1 = new Book
//final关键字修饰的是book1变量,不能给book1变量重新赋值,可以对象的字段值
//    book1 = new Book
book1.name =   
} 
}

package com.bjpowernode.chapter01.demo04.p5;
/**
* 5) final修饰方法形参
* final形参不能被赋值
* @author Administrator
*
*/
public class Test {
public static void main(String[] args) {
m1(10, 20); //在调用方法时, 给final形参初始化
}
public static void m1( int x, final int y ) {
x = 101;
//    y = 202;    //final形参不能被赋值
}
}

Java抽象类

当一个类的某个操作没法具体实现时,这个操作可以定义为抽象方法。

抽象方法使用abstract修饰的方法,只有方法的声明部分,没有方法体。

package com.wkcto.chapter01.abstracttest.demo01;
/**
* 定义平面图形 类
* 该类有对平面图形求面积,求周长的操作
* 
* 1) 当一个类的某个操作没法具体实现时, 这个操作可以定义为抽象方法
* 2) 使用abstract修饰的方法为抽象方法, 只有方法的声明,没有方法体
* 3) 含有抽象方法的类必须定义为抽象类
* @author 
*
*/
public abstract class Graphics2d {
//定义抽象方法,求面积
public abstract double getArea();
//定义抽象方法,求周长
public abstract double getPerimeter();    
}

package com.wkcto.chapter01.abstracttest.demo01;
/**
 * 定义矩形类
 * 
 *     1) 子类继承了抽象类, 需要在子类中重写抽象类的抽象方法
 * @author 
 *
 */
public class Rectangle extends Graphics2d {
    int width;
    int height;    
    public Rectangle(int width, int height) {
        super();
        this.width = width;
        this.height = height;
    }
    @Override
    public double getArea() {
        return width*height;
    }
    @Override
    public double getPerimeter() {
        return 2*(width+height);
    }
}

package com.wkcto.chapter01.abstracttest.demo01;
/**
 * 测试类,
 *     定义一个方法,可以显示任意平面图形的面积与周长
 * @author 
 *
 */
public class Test {
    public static void main(String[] args) {
        //创建矩形 对象
        Rectangle rect = new Rectangle(10, 5);
        //方法的形参graphics2d是一个父类引用,在调用方法时, 可以传递子类对象
        showInfo(rect);        
        //创建圆形对象
        Circle c1 = new Circle(10);
        showInfo(c1);
    }
    //    定义一个方法,可以显示任意平面图形的面积与周长
    public static void showInfo( Graphics2d graphics2d) {
        System.out.println("平面图形的信息------------------");
        System.out.println("面积:" + graphics2d.getArea());
        System.out.println( "周长:" + graphics2d.getPerimeter());
    }
}

package com.wkcto.chapter01.abstracttest.demo01;
/**
 * 定义三角形类
 *         如果子类继承了抽象类, 没有重写所有的抽象方法,那么子类也需要定义为抽象类
 * @author 
 *
 */
public abstract class Triangle extends Graphics2d {
    int a;
    int b;
    int c;    
    @Override
    public double getPerimeter() {
        return a+b+c;
    }
}

package com.wkcto.chapter01.abstracttest.demo01;
/**
 * 测试抽象类的特点:
 *     1) 只要使用abtract修饰的类就是抽象类
 *     2) 含有抽象方法的类必须定义 为抽象类,但是,抽象类中不一定含有抽象方法
 *         有时,对现有的类进一步抽象形成更高层级的类(更抽象的类),如食物类,动物类, 它们是没法实例化,这种情况下,可以定义为抽象类
 *     3) 抽象类是一种引用数据类型, 可以定义变量, 但是抽象类不能实例化对象,
 *         抽象类定义引用可以赋值子类对象
 *     4) 抽象类肯定含有构造方法, 子类创建对象时调用子类构造方法,子类构造方法体执行前会先执行父类的构造方法
 *     5) abstract与final不能同时使用
 * @author 
 *
 */
public class Test02 {
    public static void main(String[] args) {
        //使用抽象类定义一个变量
        Graphics2d graphics2d;
//        graphics2d = new Graphics2d();;//Cannot instantiate the type Graphics2d        
        Rectangle rectangle = new Rectangle(10, 5);        
        //抽象类引用可以赋值子类对象
        graphics2d = rectangle;
        graphics2d = new Rectangle(5, 2);                
    }
}

练习: 主人喂养宠物,宠物就卖萌

package com.wkcto.chapter01.abstracttest.demo02;
/**
 * 宠物类
 *         卖萌
 * @author 
 *
 */
public abstract class Pet {
    //卖萌
    public abstract void sellMeng() ;
}

package com.wkcto.chapter01.abstracttest.demo02;
/**
 * 小狗是宠物
 * @author 
 *
 */
public class Dog extends Pet {
    @Override
    public void sellMeng() {
        System.out.println("汪汪汪~~~~");
    }
}

package com.wkcto.chapter01.abstracttest.demo02;
/**
 * 主人类
 * @author 
 *
 */
public class Master {
    //喂宠物
    public void feed( Pet  pet) {
        //宠物卖萌
        pet.sellMeng();
    }
}

package com.wkcto.chapter01.abstracttest.demo02;
/**
 * 测试主人喂宠物,宠物就卖萌
 * @author 
 *
 */
public class Test {
    public static void main(String[] args) {
        Master xiaoxi  = new Master();        
        Dog dog = new Dog();
        xiaoxi.feed(dog);        
        Cat cat = new Cat();
        xiaoxi.feed(cat);
    }
}

大家可以自己练习下:

愤怒的小鸟, 红火(红颜色的鸟)可以正常飞行 , 蓝冰(蓝颜色的鸟)可以一个变三个, 黄蜂(黄颜色的鸟)可以加速飞行, 定义一个弹弓类,有一个弹射的方法 ,可以把鸟给射出去, 鸟在飞。

• 上面就是《Java中final关键字的作用和Java抽象类》。的分享，接下来为大家梳理《Java接口和Java类与类之间的关系》。
• 也欢迎大家交流探讨，该文章若有不正确的地方，希望大家多多包涵。
• 你们的支持就是我最大的动力，如果对大家有帮忙给个赞哦~~~