Abstract,static,final理解
一 . Abstract 抽象
1> 修饰类
一个类被Abstract修饰之后,就不能new对象了,修饰父类
- 被Abstract修饰的说明是一个不是一个具体的类型,是一个类别,是一个父类,不应该被具体化
- 说明这个类不完整,不够具体,抽象类无法独立存在
为子类输出共性
作用:
1> 可以被子类继承,提供共性属性和方法
2> 可声明为引用,强制使用多态
3> 抽象父类可以是子类的组成部分,依附于子类对象的存在
4> 由父类共性+子类独有组成完整的子类对象
5> 抽象类也是有构造方法的,可以由子类来调用,构建子类对象时调用父类构造方法
6> 和普通类的区别,就是不能new,其他和普通的类都一样2> 修饰方法
抽象方法:只有声明,没有实现,不够完整
- 方法的声明时必要的,可是发放的实现是多余的,因为父类的方法的实现是无法满足子类的需求的,最后子类都会进行重写
- 含有抽象方法的类必须是个抽象类
- 抽象类中不一定有抽象方法
子类必须重写父类的所有的抽象方法
//如果父类是个抽象
//那么子类必须重写父类的所有的抽象方法
//抽象类中不一定有抽象方法
abstract class Animal{//含有不完整的方法,那么这个类也是不完整的
String bread;
int age;
public Animal(){
System.out.println("这是抽象类的无参构造函数..");
}
//这是一个抽象方法
//含有抽象方法的类必须是个抽象类
public abstract void eat();//只有声明,没有实现,意为不完整
//还可以拥有普通的方法
public void slep(){};
}
//一个抽象类的子类
class Dog extends Animal{
//必须重写父类所有的抽象方法
public void eat(){
}
}
//子类不想实现父类的抽象方法
//那么这个类也必须是个抽象类
//同时继承父类所有的未实现的抽象方法
abstract class Cat extends Animal{
}二 . static 静态
类加载时.在方法区中,会存放一个有MyClass对象的类信息,MyClass.class
普通的实例变量是在创建对象的时候在内存中创建对象
静态方法是在类加载时就在内存中创建对象
静态方法允许直接访问静态成员
静态方法不能直接访问非静态成员
静态方法中不允许使用this和super关键字
静态方法可以继承,不能重写,没有多态
扫描二维码关注公众号，回复： 9491426 查看本文章
- 动态方法要到运行时才是可以明确执行的是哪个,因为不能确定是否有子类将他重写覆盖了
- 静态方法不用到运行时,编译时就会知道了.运行时不可变
java中方法的调用分为两种
1> 静态分派: 静态方法中,允许参数列表不同的重名方法,指静态方法之间的重载
2> 动态分派: 在具有继承关系的情况下,调用实例方法时,自低向上(先查子类,再找父类,一直向上查找)查找可 用的方法版本,指实例方法的覆盖
jvm方法调用的指令:
1> invokespacial 调用私有方法和构造方法
2> invokeinteface 调用接口方法
3> invokestatic 调用静态方法
4> invokevirtual 调用虚方法(父类定义的,日后被子类覆盖的方法)
5> invokedynamic 调用动态链接方法
public class TestStatic{ public static void main(String[] args){ A.staticMethod(); B.staticMethod();//继承了父类的静态方法,但是不能重写,所以不存在多态 A a = new B(); //也是可以掉调用的,即使在子类中也有一个同样的静态方法 //下面的方法调用的依然是父类中的静态方法 //因为静态方法不能被覆盖 a.staticMethod(); } } class A{ static int find; public static void staticMethod(){ System.out.println("----" + find); } } class B extends A{ //假如B中也存在一个,也是不行的,不能覆盖 public static void staticMethod(){ System.out.println("----" + find); } }
1> 静态属性(类属性)
静态成员是全类所有对象共享的成员
在全类中只有一份,不因创建多个对象而产生多份
不必创建对象,可以直接通过类名访问
a .普通的属性
public class TestStatic{
public static void main(String[] args){
MyClass mc1 = new MyClass();
m1.a = 10;
//每个对象都拥有自己单独的a
//每个对象都在堆中用一个自己的a空间,指向栈中的mc2引用
MyClass mc2 = new MyClass();
m2.a = 20;
System.out.println(m1.a + "--" + m2.a);//输出结果: 10 -- 20
}
}
class MyClass{
//每个对象都持有一例
int a; //实例属性
}b.静态属性
public class TestStatic{
public static void main(String[] args){
//m1.b和m2.b访问的都是方法区中的b,是同一个
//每个类的实例都是使用的这一个b
MyClass mc1 = new MyClass();
MyClass mc2 = new MyClass();
m1.a = 10;
m2.a = 20;
m1.b = 100;
m2.b = 202;//覆盖了前面的m1赋值的100//自动转换 m2.b --> MyClass.b
//不用通过对象名访问静态属性
//直接使用类名访问
MyClass.b = 200;
System.out.println(m1.a + "--" + m2.a);//输出结果: 10 -- 20
System.out.println(m1.b + "--" + m2.b);//输出结果: 200 -- 200
}
}
class MyClass{
//实例属性
int a;
//在这个类加载的时候,这个static属性就放到方法区了\
//整个类的共享的.只有单独的一份
static int b; //静态属性
}2> 静态方法
class Student{
//静态方法
//类的所有对象公用
public static void method(){
}
public void fan(){
//同一个类的其他方法使用本类的静态方法,直接使用方法名
method();
}
}
class Test{
public static void main(String[] args){
//类外使用静态方法
//类名.方法名
Student.method();
}
}3> static高级应用
1-类加载
JVM 首次使用某个类的时候,是需要通过CLASSPATH查找该需要使用类的.class文件
将.class文件中对类的描述信息加载到内存中,进行保存(比如:包名,类名,属性,方法,构造方法等信息)
- 加载的时机
- 创建对象
- 创建子类对象
- 访问静态属性
- 调用静态方法
- Class.forName("全限定名") :(主动加载一个类,但是不接收返回值,只是加载到内存中,目前并不使用)
class TestClassLoaded{
public static void main(String[] args){
new Super();//首次用到,创建了一个类的对象,就需要加载这个类
Super.sMethod();//或者这个类中有静态方法,那么在首次调用这个静态方法的时候,也会加载这个类
Super.sname;//同上
Sub.sMethod();//调用父类的静态方法,首次使用也会加载super类,
}
}
class Super{
String name;
static String sname;//静态属性
//静态方法
public static void sMethod(
{
}
}
class Sub extends Super{
}2-静态代码块
- 静态代码块是由类加载触发的(仅一次)
- 可为静态属性赋值,或者必要的初始行为
- 首先加载执行静态属性和静态代码块
- 再来加载普通属性和动态代码块和构造方法
public class Test{
public static void main(String[] args){
//静态代码块是由类加载触发的
new MyClass;
System.out.print(MyClass.sname);//这两个都会执行静态代码块
}
}
class MyClass{
//静态属性
static int sname = 88;
int name = 99;
//静态代码块
static{
System.out.print("这诗集静态代码块中得到输出");
//使用了静态的属性
//执行静态代码块和静态属性的时候,根据书写顺序加载
//如这里使用了sname静态属性,那么这个属性必须定义到静态代码块前面
System.out.print(sname);
}
MyClass{
System.out.print("类中音译的属性值为: " + name);
System.out.print("这是构造方法中得到输出");
}
public void m1(){
int a = 10;
}
}3- 各个模块之间的执行顺序
package com.huqi.demo1;
public class TestLoadSort{
public static void main(String[] args) throws Exception{
//new Super();
new Sub();//创建一个子类的对象,查看加载各个属性和代码块的顺序
//主动加载一个类,只执行静态代码的部分
Class.forName("com.huqi.demo1.Sub");//里面的必须带包名
/*
如果只执行这一行代码,则会输出下面的语句,这个是类级别的,从这里下面的代码都是对象级别的
这是父类的静态方法---
这是父类的静态代码块---
这是子类的静态方法---
是子类的静态代码块---
*/
}
}
class Super{
static String staticField = "这是父类的静态方法---";
static{
System.out.println(staticField);
System.out.println("这是父类的静态代码块---");
}
String instanceField = "这是父类的成员属性---";
{
System.out.println(instanceField);
System.out.println("这是父类的动态代码块---");
}
public Super(){
System.out.println("这是父类的构造方法---");
}
}
class Sub extends Super{
static String staticField2 = "这是子类的静态方法---";
static{
System.out.println(staticField2);
System.out.println("这是子类的静态代码块---");
}
String instanceField2 = "这是子类的成员属性---";
{
System.out.println(instanceField2);
System.out.println("这是子类的动态代码块---");
}
public Sub(){
System.out.println("这是子类的构造方法---");
}
}当new Sub时的结果
这是父类的静态方法---
这是父类的静态代码块---
这是子类的静态方法---
这是子类的静态代码块--- //从这里分割,前面的是类几级别的,类加载时运行,后面的都是创建对象时执行
这是父类的成员属性---
这是父类的动态代码块---
这是父类的构造方法---
这是子类的成员属性---
这是子类的动态代码块---
这是子类的构造方法---
当new Super时的结果:
这是父类的静态方法---
这是父类的静态代码块---
这是父类的成员属性---
这是父类的动态代码块---
这是父类的构造方法---三.final
- final修饰类: 此类不能被继承
- final修饰方法: 此方法不能被覆盖
- final修饰变量:此变量值不能被改变(无初始值.只允许赋值一次)
- 局部变量 :显示初始化
- 实例变量: 显示初始化,动态代码块,构造方法
- 静态常量: 显示初始化,静态代码块
- 基本数据类型常量:值不可改变
- 应用数据类型常量: 地址不可变
1> final类
- final修饰类: 此类不能被继承.
- String.math.System均为final修饰的类,不能被继承
- final修饰的方法不能被覆盖
public class testFinal{
}
//final不能和abstract一起使用,是冲突的两个
final class Super{
}
//发生错误,不能继承被final修饰的类
final Sub extends Super{
}2> final变量
final修饰变量,就变成了常量
- 用final修饰的属性没有默认值
只能赋一次值
public class testFinal{
main(){
//用final修饰的是常量
//先赋值再使用
final double PI = 3.1415;
}
}
//final不能和abstract一起使用,是冲突的两个
final class Super{
//没有默认值,必须要初始化
//在对象初始化完成之前完成初始化的操作
final int field = 10;
final int FIELD;
public Super(){
//对常量进行初始化
FIELD = 20;
}
//静态常量
final static void STATIC_FIELD = 20;
static{
//可以给STATIC_FIELD赋值
//STATIC_FIELD = 20;
}
}