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关键字




• 静态方法可以继承,不能重写,没有多态

  
  
  • 动态方法要到运行时才是可以明确执行的是哪个,因为不能确定是否有子类将他重写覆盖了
  
  
  • 静态方法不用到运行时,编译时就会知道了.运行时不可变
  
  

  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;
}}