Java面向对象（一）---static（静态）、final（最终）、abstract（抽象）、interface（接口）

static（静态）

关键字、修饰符 变量、方法、代码块、内部类

1.静态变量

静态变量随着类的加载（方法区的静态常量值）而加载到方法区的静态区，与类同级也叫类变量，通过类名.形式来调用静态变量也可以通过对象来调用静态变量。存储在方法区静态区时会默认给静态变量赋予系统默认初始值。类产生的对象共享一个静态变量（属性），看静态变量是否需要被所有的对象来共享，如果需要共享就设置成静态变量。

方法里可以定义静态变量？
静态变量与类同级，只有方法被调用时里面的内容才能出现，前后矛盾，不能定义

内存图：

代码：

package cn.tedu.staticx;

public class StaticDemo1 {
    public static void main(String[] args) {
        //创建对象
        Person p=new Person();
        p.name="郭靖";
        p.age=2;
        p.gender='男';
        //创建对象
        Person p1=new Person();
        p1.name="黄蓉";
        p1.age=3;
        p1.gender='女';
        //输出
        System.out.println(p.toString());
        System.out.println(p1.toString());
    }
}

//定义代表人的类
class Person{
    //属性
    String name;
    int age;
    static char gender;

    //定义方法来输出对象的属性值
    public String toString(){
        return this.name+","+this.age+","+this.gender;
    }
}

执行结果：

2.静态方法

静态方法会随着类的加载而加载到方法区的静态区，与类同级也叫作类方法，通过类名.形式来调用也可以通过对象调用。静态区不会给静态方法赋予系统默认初始值，当main方法被调用会加载到栈中执行。

Java中所有的静态信息只能直接使用静态信息，所有的非静态信息可以直接使用静态信息以及非静态信息

package cn.tedu.staticx;

public class StaticDemo2 {


    //静态变量
    static int i=1;
    //非静态变量
    int j=2;
    //静态方法可以直接使用静态变量
    public static void m(){
        System.out.println(i);
        //静态方法不能直接使用非静态变量
        //成员变量与对象一个级别，静态方法与类一个级别
        //类加载静态方法时不能直接使用还没有出现的信息
        // System.out.println(j);
    }
    //非静态信息与对象同级可以直接使用前面类以及加载信息
    public void n(){
        //非静态方法可以直接使用静态变量
        System.out.println(i);
        //非静态方法可以直接使用非静态变量
        System.out.println(j);
    }
}

静态方法支持重载？支持

静态方法支持重写？不支持重写，静态方法与对象同级，重写针对的是对象级别不一样，静态方法没有提供重写。父子类中要么出现方法签名一致的都是非静态方法（重写）要么都是静态方法（没有重写）。

Arrays.toString();
Arrays.sort();
System.arraycopy();
Arrays.copyOf();

代码：

package cn.tedu.staticx;

public class StaticDemo3 {
    public static void main(String[] args) {
        //向上造型
        SDemo s=new SDemo1();
        //如果执行子类方法说明一定有重写
        s.m();
    }
}


class SDemo{
    public void m(){
        System.out.println(1);
    }
    public static void n(){}
}
class SDemo1 extends SDemo{
    //注释--给计算机看的注释
    //@Override表明下面的方法是重写方法
    @Override
    public void m(){
        System.out.println(2);
    }
    //加注释在报错说明不是重写方法
    //静态方法与类同级
    //重写--运行时多态--针对的是对象--和对象一个级别
    //@Override
    public static void n(){}
}

执行结果：

3.静态代码块

a.可以给静态变量进行初始化
b.预先加载资源
c.随着类的加载而只加载一次
d.static修饰的静态信息都只加载一次
e.父子类执行顺序（类级别（先父后子），对象级别（先父后子）父类静态信息-子类静态信息-父类对象级别信息-子类对象级别信息）

代码：

package cn.tedu.staticx;

public class StaticDemo4 {
    public static void main(String[] args) {
        new SDemo2();
        new SDemo2();
    }

}
class SDemo2{
    static int i;//静态变量
    //静态代码块
    //给静态变量进行初始化
    //预先加载资源
    //因为静态代码块随着；类的加载而加载，但是类只加载一次
    static {
        i=1;
        System.out.println("静态代码块");
    }
    {
        System.out.println("构造代码块");
    }
    public SDemo2(){
        System.out.println("构造方法");
    }

}

执行结果：

1.

package cn.tedu.staticx;

public class StaticTest2 {
    public static void main(String[] args) {
        System.out.println(new STDemo().i);
    }
}

class STDemo{
    int i=5;
    {
        i=1;
    }
}

2.

package cn.tedu.staticx;

public class StaticTest3 {
    public static void main(String[] args) {
        System.out.println(STDemo1.x+","+STDemo1.y);
    }
}

class STDemo1{
    /*
         加载       执行第一步    执行第二步    执行第三步
    *    st=null    st=0x01      st=0x01    st=0x01
         x=0        x=1            x=1      x=1
         y=0        y=1            y=1      y=3
    * */
    static STDemo1 st=new STDemo1();
    static int x;
    static int y=3;
    public STDemo1(){
        x++;
        y++;
    }
}

执行结果：

3.代码：

package cn.tedu.staticx;

public class StaticTest3 {
    public static void main(String[] args) {
        System.out.println(new STDemo1().x+","+new STDemo1().y);
    }
}

class STDemo1{
    //StackOverflowError--报错--栈溢出错误
    STDemo1 st=new STDemo1();
    static int x;
    static int y=3;
    public STDemo1(){
        x++;
        y++;
    }
}

分析内存图：

执行结果：

final（最终）

关键字、修饰符 数据、方法、类

1.最终值

当final修饰基本数据类型数据时是值不能改变
当final修饰引用类型数据时是地址值无法改变

package cn.tedu.staticx;

public class FinalDemo1 {
    public static void main(String[] args) {
        //当引用指向的数据可以改变时表明是变量
        int x=1;
        //当final来修饰基本类型数据时保证值不能改变
        //当引用不能改变时就是常量
        final int i=1;//自定义常量
        int j=i+1;
        //i++;

        //当final修饰引用类型时地址值不能改变
        final int[] arr={1,2,3};
        arr[0]=10;
        //arr=new int[3];//报错
        //数组长度是被final修饰
        //arr.length=10;//报错
    }
}

当final修饰成员变量，保证对象创建完成之前给值
当final修饰静态变量时（静态常量），保证类加载完成之前给值

package cn.tedu.staticx;

public class FinalDemo2 {
    public static void main(String[] args) {

    }
}

class FDemo{
    //属性--成员变量
    //保证对象创建完成之前给值
    final static int i;//静态常量

    //静态代码块可以给静态变量进行初始化
    static {
        i=2;
    }
    
    //构造代码块
    {
        i=2;
    }

    /*//保证每个构造方法都要赋值
    public FDemo(){
        i=2;
    }
    public FDemo(int j){
        i=j;
    }*/
}

2.最终方法

支持重载但是不支持重写

package cn.tedu.staticx;

public class FinalDemo3 {

}

class FDemo1{
    public final void n(){}
    //支持重载
    public final void n(int i){}
}
class FDemo2 extends FDemo1{
    //@Override
    //不支持重写
    public final void n(){}
}

3.最终类

不能有子类但是可以有父类

package cn.tedu.staticx;

public class FinalDemo4 {
}
//最终类不能被继承
class FDemo3{}
//最终类可以继承别的类
class FDemo4 extends FDemo3{}

abstract（抽象）

关键字，修饰符 方法、类

当所有的子类对父类的某个方法都进行不同程度的重写，那么这个方法的方法体没有了实际含义，就可以把方法体直接去掉加上abstract关键字修饰方法–抽象方法。一个类中如果出现了抽象方法那么这个类就要变成抽象类。普通类继承了抽象类需要重写所有的抽象方法，如果不想重写抽象方法可以把普通类变成抽象类

package cn.tedu.abstractx;

public class AbstractDemo1{
    public static void main(String[] args) {

    }
}

interface Outer5{

    //接口里定义接口，默认被static修饰
    interface Inner6{
        int j=1;
    }
    //接口里定义内部类默认被static修饰
    class Inner5{
        static int i=1;

        //类里定义接口
        static interface Inner7{
            int x=1;
        }

    }


}

注意：
1.抽象方法可以重载？可以
2.抽象类一定含有抽象方法？不一定 抽象类里不一定含有抽象方法，但是抽象方法所在的类一定是抽象类
3.抽象类里可以定义属性和方法？可以
4.抽象类里可以定义构造方法？可以 给属性进行初始化
5.抽象类可以创建对象？不可以，没有对象
6.抽象方法可以被private/final/static分别修饰？不可以，三种修饰符都没有被重写，所以不能修饰抽象方法
7.抽象类可以被final修饰？不可以，final修饰的类不能被继承，抽象类里的抽象方法需要被重写，抽象类需要被继承，不能被修饰
8.宗旨就是延展类的继承结构

interface（接口）

当抽象类中所有的方法都是抽象方法时可以把抽象类变成接口来表示（用interface）。接口本质不是类，类和接口之间是通过implements产生关联关系—实现。Java支持接口与接口之间是多继承，类与接口之间是多实现，为了实现类具有更多丰富的功能。实现类需要重写接口所有的抽象方法，如果不想都重写，可以把实现类变成抽象类。

package cn.tedu.abstractx;

import java.io.Serializable;

public class AbstractDemo1 {
    public static void main(String[] args) {
        //接口名.属性--静态属性
        System.out.println(Shape.i);
    }

}

//代表图形的类
//当抽象类里都是抽象方法时可以吧 把这个类转成接口表示
//接口本质不是类
//接口与接口之间支持多继承
interface Shape extends Cloneable, Serializable {
    //属性--默认被public、final、static共同修饰
    public final static int i=1;
    public abstract double getGirth();
    public abstract double getArea();
}
//普通类
//implements---代表类与接口之间的实现关系
//实现类
//类与接口之间支持多实现
//实现类需要把接口里的所有抽象方法进行重写，如果不想都重写，可以把这个实现类变成抽象类
abstract class Rectangle implements Shape ,Cloneable{

    /*@Override
    public double getGirth() {
        return 0;
    }*/

    @Override
    public double getArea() {
        return 0;
    }
}

注意：
1.接口里的方法都是抽象方法？接口里的方法都是抽象方法（和版本有关系）
2.接口里可以定义构造方法？不能定义构造方法
3.接口可以创建对象？不可以
4.接口里可以定义属性？可以定义并且默认被public、static、final共同修饰，抽象方法默认被public、abstract共同修饰
5.接口声明的对象在编译时期可以接收所有的类型对象的赋值，但是在运行时期检测对象实际创建类是否是接口的实现类
6.宗旨就是为了给实现类注入更多的功能

抽象类和接口的区别

1.接口不是类
2.接口里方法都是抽象方法
3.类与接口支持多实现，接口与接口实现多继承
4.接口里的属性和抽象方法有默认修饰符共同修饰（public、static、final）
5.接口里不能定义构造方法
6.抽象类的目的是为了延展类继承结构，接口是为了注入更多的特性

接口的优点:模板、约束