Java面向对象：static，抽象类，接口，内部类

抽象类（abstract）：
abstract既可修饰类也可修饰方法；即抽象类与抽象方法
抽象类中可以没有抽象方法，但有抽象方法的类一定要声明为抽象类
抽象类不能用new关键字来创建对象，它是用来让子类继承的
抽象方法只有方法的声明，没有方法的实现，它是用来让子类实现的
子类继承抽象类，那么就必须要实现抽象类没有实现的抽象方法，否则该子类也要声明为抽象类

接口：
普通类：只有具体实现
抽象类：具体实现和规范（抽象方法）都有
接口：只有规范，自己无法写方法，专业的约束。接口和实现分类：面向接口编程
接口就是规范，定义的是一组规则
接口的本质是契约，就像法律，制定后大家都得遵守

内部类：
内部类就是在一个类的内部再定义一个类
1.成员内部类
2.静态内部类
3.局部内部类
4.匿名内部类

详见代码：

 

package com.zdz.oop;
//static
//静态导入包
import static java.lang.Math.random;
public class Students extends Action{//继承抽象类，必须实现它的方法，除非子类也为抽象类
    private static  int age;//静态变量  多线程
    private double score;//非静态变量

    //序号为执行顺序
    {//2
        //匿名代码块
        System.out.println("匿名代码块");
    }
    static {//1.只执行一次
        //静态代码块
        System.out.println("静态代码块");
    }

    public Students(){//3
        System.out.println("构造方法代码块");
    }

    public void run(){

    }

    public static void go(){

    }

    public static void main(String[] args) {
        Students students = new Students();
        //静态变量
        System.out.println(Students.age);//静态变量可直接调用，不需要new
        System.out.println(students.age);//new
        System.out.println(students.score);//new
        //静态方法
        Students.go();//直接调用
        //非静态方法
        new Students().run();//new

        System.out.println(random());

        //内部类
        Outer outer = new Outer();
        Outer.Inner inner = outer.new Inner();
        inner.in();
        inner.getId();
        inner.getOut();

    }

    //继承抽象类，必须实现它的方法，除非子类也为抽象类
    @Override
    public void doSometing() {
        System.out.println("重写抽象方法");
    }
}

//abstract 抽象类 extends：单继承，有局限，不能多继承；接口可以多继承
abstract class Action{
    //约束~有人帮我们实现
    //abstract 抽象方法 只有方法名，没有方法实现
    public abstract void doSometing();
    public void Boring(){
        System.out.println("张生写代码快无聊死了");
    }

    public Action() {//存在构造方法
    }
/*
    1.不能new这个抽象类，只能靠子类去实现它；约束
    2.抽象类中可以写普通方法
    3.抽象方法必须在抽象类中
    存在意义：将共有属性抽象出来，提高开发效率
     */

}

//接口
/*
作用
1.约束
2.定义一些方法让不同的人实现
3.接口不能被实例化，接口没有构造方法
4.implements可以实现多个接口
5.必须重写接口中的方法
 */
interface X{
    //接口里都是常量 默认：public static final
    int AGE=22;

    //接口定义的方法都是抽象的：public abstract
    void add();
    void delete();
    void aupdate();
    void query();
}
interface Y{
    void eat();
    void sleep();
}

//接口的实现
//implements实现接口，必须重写接口内的方法
class Z implements X,Y{//可实现多个接口，等同于多继承

    @Override
    public void add() {

    }

    @Override
    public void delete() {

    }

    @Override
    public void aupdate() {

    }

    @Override
    public void query() {

    }

    @Override
    public void eat() {

    }

    @Override
    public void sleep() {

    }
}

//内部类
class Outer{
    private int id=10;
    public void out(){
        System.out.println("这是外部类的方法");
    }
    //成员内部类
    public class Inner{
        public void in(){
            System.out.println("这是内部类的方法");
        }

        //获得外部类的私有属性
        public void getId(){
            System.out.println(id);
        }
        //获得外部类方法
        public void getOut(){
            out();
        }
    }

    //静态内部类
    public static class InnerStatic{

    }

    //局部内部类
    public void test(){
        class Test{

        }
    }
    //
}

 

————————————————
版权声明：本文为CSDN博主「张生说」的原创文章，遵循CC 4.0 BY-SA版权协议，转载请附上原文出处链接及本声明。
原文链接：https://blog.csdn.net/zhangduang1/article/details/114839753