Java学习第十天--三大修饰符(abstract final static)

一 abstract

含义:抽象的,可修饰类 方法

abstract修饰的类称为抽象类,修饰的方法称为抽象方法

抽象类

特点:不能创建对象(多用于继承)

格式;

访问权限修饰符 abstract class 类名{

        }

除了不能创建对象其他与别的类一样

抽象方法

特点:没有方法体

格式:

访问权限修饰符 abstract 返回值类型 方法名(形参列表);

注意:1 有抽象方法的类一定是抽象类,抽象类不一定有抽象方法

         2 子类继承抽象类时,要么重写抽象方法,要么自己本身就是抽象类

例题:假如我们在开发一个系统时需要对员工类类进行设计，程序员是员工，包含3个属性：姓名、工号以及工资。经理也是员工，除了含有员工的属性外，另为还有一个奖金属性。员工的抽象方法,工作.程序员工作是写代码.经理的工作是查询工作进度

package com.qf.demo01;

public abstract class YuanGong {
	public String name;
	public int num;
	public double money;
	
	public YuanGong() {
		super();
	}

	public YuanGong(String name, int num, double money) {
		super();
		this.name = name;
		this.num = num;
		this.money = money;
	}

	
	public String getName() {
		return name;
	}

	public void setName(String name) {
		this.name = name;
	}

	public int getNum() {
		return num;
	}

	public void setNum(int num) {
		this.num = num;
	}

	public double getMoney() {
		return money;
	}

	public void setMoney(double money) {
		this.money = money;
	}

	public abstract void work(String work);
}

package com.qf.demo01;

public class ChengXvYuan extends YuanGong{
	
	public ChengXvYuan(String name,int num,double money) {
		super(name,num,money);
		this.name = name;
		this.num = num;
		this.money = money;
	}
	
	public void work(String work) {
		System.out.println("程序员"+name+"的工作是"+work+"工号是"+num+"工资是"+money);
	}
}

package com.qf.demo01;

public class JingLi extends YuanGong{
	private double good;
	
	public JingLi(String name,int num,double money,double good) {
		super(name,num,money);
		this.name = name;
		this.num = num;
		this.money = money;
		this.good = good;
	}
	public void work(String work) {
		System.out.println("经理"+name+"的工作是"+work+"工号是"+num+"奖金是"+good+"总工资是"+(money+good));
	}
}

package com.qf.demo01;

public class Demo01 {
	public static void main(String[] args) {
		ChengXvYuan monkey = new ChengXvYuan("张三", 111, 8000);
		monkey.work("敲代码");
		JingLi monkey02 = new JingLi("李四", 222, 10000, 5000);
		monkey02.work("查询工作进度");
	}
}

二 final

含义:最终的,不可修改的

final可以修饰:类 变量 方法

使用final修饰的类 变量 方法均不可以再修改

final修饰的类(最终类)

特点;不能被继承

格式:

访问权限修饰符 final class 类名{

}

final修饰的变量

特点:不能改变,也可称为常量

成员变量(属性):
        语法:访问权限修饰符 fianl 数据类型 属性名 = 值;
1,必须在声明时赋值
2,属性值不能被修改
局部变量:
        语法:fianl 数据类型 变量名 = 值;
1,可以将声明与赋值分开,但是只能赋值一次
注意:常量名要使用全大写

修饰方法:
特点:不能被重写
语法:
        访问权限修饰符 final 返回值类型 方法名(形参列表){
                方法体
        }

abstract与final是否可以同时使用?为什么?
不能同时使用
abstract与final都可以修饰的有类或方法
abstract修饰的类就是为了让其他类继承,如果同时使用final修饰又不允许被其他类继承.此时
互相矛盾,所以在类上不能同时使用
abstract修饰的方法为抽象方法,是为了让子类重写.但是final修饰的方法不能重写,也互相矛
盾,所以不能同时使用

三 代码块

作用:封装一段代码
语法:{}
注意:如果在类中方法以外单独出现,是每次创建该类对象时调用,而且在调用构造函数之前

四 static

含义:静态的

static可以修饰:成员变量,方法,内部类,代码块

修饰成员变量:
称为:静态属性
特点:
        1,static修饰的属性属于该类的所有对象共有的
        2,可以使用类名调用,也可以使用对象调用
语法:
        访问权限修饰符 static 数据类型 变量名;
如:
        class A{
                public static int num;
                public A(int num){
                        this.num = num;
        }
                public int getNum(){
                        return num;
                }
        }
        class Test{
                public static void main(String[] args){
                        A a1 = new A(11);
                        A a2 = new A(1);
                        A a3 = new A(99);
                        A a4 = new A(0);//此时num的值0
                }
        }

修饰方法:
称为:静态方法
特点:
        1,可以使用类名直接调用,也可以使用对象名调用
语法:
        访问权限修饰符 static 返回值类型 方法名(形参列表){
                方法体
        }
注意:
        1,静态方法中可以直接使用静态成员(静态属性与静态方法),不能直接使用非静态成员(非静态属性或非静态方法)
        2,静态方法中不能使用this或super关键字
修饰代码块:
称为:静态代码块
特点:
        在当前类被加载时执行一次
语法:
        static{
        }
定义的位置:类中方法以外
注意:
        一个类只会被加载一次

类加载的时机

1,首次创建该类对象时
2,未创建该类对象,但是首次创建其子类对象时
3,使用类名第一次调用该类中的静态属性或静态方式时
4,获取该类的类对象.使用反射技术对该类进行操作时

练习:统计A类对象的创建次数
分析:
        每次创建对象时都会执行代码块中的代码
        定义一个静态属性用于记录已经创建的对象次数
        在代码块中使用步骤2的变量+1

package com.qf.demo01;

public class A {
	public static int num = 0;
	{
		num++;
	}
}

package com.qf.demo01;

public class Demo01 {
	public static void main(String[] args) {
		A a01 = new A();
		A a02 = new A();
		A a03 = new A();
		A a04 = new A();
		A a05 = new A();
		System.out.println("num的值为"+A.num);
		System.out.println("A类对象共调用了"+A.num+"次");
	}
}

静态与非静态的区别

静态属性与非静态属性的区别
静态属性
        1,属于该类的所有对象
        2,可以使用类名直接调用,也可以使用对象名调用
        3,随着类的加载而生成,随着类的销毁而销毁
非静态属性
        1,属于该对象
        2,只能使用对象名调用
        3,随着对象的创建而生成,随着对象的销毁而销毁
静态方法与非静态方法
静态方法:
        1,可以类名直接调用,也可以使用对象名调用
        2,方法体中不能直接使用非静态成员(静态方法与静态属性)
        3,不能使用this与super关键字
非静态方法:
        1,只能使用对象名调用
        2,方法体中能直接使用非静态成员(静态方法与静态属性)
        3,能使用this与super关键字
静态代码块与非静态代码块
静态代码块
        类加载时调用
非静态代码块
        创建该类对象时被调用

代码执行流程

1,将java文件编译为class文件 编译
2,jvm加载class文件 加载
3,执行class文件中的代码 运行
步骤:
        1,编译
        2,加载
                1,将class中的内容放到对应的内存区域
                        静态区,常量区,代码区,方法区,堆栈
                2,给类的静态属性赋初值
                3,执行静态代码块中的代码
        3,运行
                main方法进入后,从上到下依次执行
                在运行过程中如果发现了这个类第一次使用那么就会加载这个类
                在运行过程中创建该类对象时
                给属性赋初始值
                先执行该类的非静态代码块
                在执行调用的构造函数