static、抽象类、接口、内部类

一.static关键字详解

1.静态的变量/方法

package Demo02;

//static

public class Student {

    private static int age;//静态的变量  多线程

    private double score;//非静态的变量

    public void run(){

    }

    public static void go(){

    }

    public static void main(String[] args) {

        Student s1 = new Student();

        System.out.println(Student.age);

        //System.out.println(Student.score);报错

        System.out.println(s1.age);

        System.out.println(s1.score);

        Student.go();

        go();

        //Student.run();报错

        new Student().run();

    }

}

2.静态代码块

package Demo02;

public class Person {

    //2:赋初始值

    {

        //代码块（匿名代码块）

        System.out.println("匿名代码块");

    }

    //1：只执行一次

    static {

        //静态代码块

        System.out.println("静态代码块");

    }

    //3

    public Person() {

        System.out.println("构造方法");

    }

    public static void main(String[] args) {

        Person person1 = new Person();

        System.out.println("==========================");

        Person person2 = new Person();

//        静态代码块

//        匿名代码块

//        构造方法

//        ==========================

//        匿名代码块

//        构造方法

    }

}

3.静态导入包

package Demo02;

//静态导入包

import static java.lang.Math.random;

import static java.lang.Math.PI;

public class test {

    public static void main(String[] args) {

        //未导入包时书写

        System.out.println(Math.random());//随机数

        //导包后书写

        System.out.println(random());

        System.out.println(PI);

    }

}

二.抽象类

1.抽象类

package Demo03;

//abstact   抽象类:类   extends:单继承

//接口可以多继承

public abstract class Action {

    //约束~有人帮我们实现~

    //abstract  抽象方法，只有方法名字，没有方法实现

    public abstract void doSomethig();

}

2.抽象类继承

package Demo03;

//抽象类的所有类方法，继承了他的子类。都必须要实现它的方法

//除非子类本身也是abstract

public class A extends Action {

    @Override

    public void doSomethig() {

    }

}

三.接口

声明类的关键字是class，声明接口的关键字是interface

1.接口UserService

package Demo04;

//interface定义的关键字，接口都需要有实现类

public interface UserService {

    //接口中的所有定义，其实都是抽象的 public abstract

    //public abstract void run();如下

    //常量  public static final int age = 99;

    int age=99;

    void add(String name);

    void delete(String name);

    void update(String name);

    void query(String name);

}

2.接口TimeService

package Demo04;

public interface TimeService {

    void timer();

}

3.实现类

package Demo04;

//抽象类   extends

//类可以实现接口   implements

//实现了接口得类，必须要重写接口中的所有方法

//多继承~利用接口实现多继承

public class UserServiceImpl implements UserService,TimeService {

    @Override

    public void timer() {

    }

    @Override

    public void add(String name) {

    }

    @Override

    public void delete(String name) {

    }

    @Override

    public void query(String name) {

    }

    @Override

    public void update(String name) {

    }

}

四.内部类

package Demo05;

public class Outer {

    public void methor(){

        class A{

            //局部内部类

        }

    }

    private int id=10;

    public void out(){

        System.out.println("这是外部类的方法");

    }

    //一个java文件中可以有多个class类，但是只能有一个public class

    class Inner{

        public void in(){

            System.out.println("这是内部类的方法");

        }

        //获得外部类的私有属性

        public void getID(){

            System.out.println(id);

        }

    }

}

package Demo05;

public class Application {

    public static void main(String[] args) {

        //new

        Outer outer = new Outer();

        //通过这个外部类来实例化内部类

        Outer.Inner inner = outer.new Inner();

        inner.in();

        inner.getID();

    }

}

ps:这里现阶段不是很懂也没关系。。。以后还会详细说

巴特西

Day15-static、抽象类、接口、内部类

static、抽象类、接口、内部类

一.static关键字详解

二.抽象类

三.接口

四.内部类

最新文章

热门文章