Static，抽象类，接口，内部类

Static

public class Student {
    private static int age; //静态的变量   多线程
    private double score;//非静态的变量

    public static void main( String[ ] args) {
        Student s1 = new Student( );
        System.out.println(Student.age) ;
       // System. out.println( Student.scofe);    //报错
        System.out.println(s1.age);
        System.out.println(s1.score) ;
    }

}

public class Student {
    private static int age; //静态的变量   多线程
    private double score;//非静态的变量

    public void run(){
        go();   //非静态方法可以调用静态方法，
    }
    public static void go(){

    }
    public static void main( String[ ] args) {
        Student.go();
        go();   //也可以直接调用，
        new Student().run();
        //run();   不能调用，
    }

}

public class Person {
    //赋初值
    {
        System.out.println("匿名代码块");
    }

    //只执行一次
    static {
        System.out.println("静态代码块");
    }

    public Person() {
        System.out.println("构造方法");
    }

    public static void main(String[] args) {
        Person person = new Person();
    }
}

抽象类

abstract修饰符可以用来修饰方法也可以修饰类,如果修饰方法,那么该方法就是抽象方法;如果修饰类,那么该类就是抽象类。
抽象类中可以没有抽象方法,但是有抽象方法的类一定要声明为抽象类。

抽象类,不能使用new关键字来创建对象,它是用来让子类继承的。
抽象方法,只有方法的声明,没有方法的实现,它是用来让子类实现的。

子类继承抽象类,那么就必须要实现抽象类没有实现的抽象方法,否则该子类也要声明为抽象类。

抽象类的继承

package aaa.demo03;
//抽象类  类 extends   单继承          接口可以单继承
public abstract class Action {
    //约束~有人帮我们实现~
    //abstract ,抽象方法，只有方法名字，没有方法的实现！
    public abstract void doSomething();

    //不能new这个抽象类，只能靠子类去实现它;约束!,它不能被实例
    //抽象类中可以写普通的方法~
    // 抽象方法必须在抽象类中

}

package aaa.demo03;

public class A extends Action{
    @Override
    public void doSomething() {

    }
}

接口

普通类: 只有具体实现
抽象类: 具体实现和规范(抽象方法)都有!
接口: 只有规范!自己无法写方法~专业的约束!约束和实现分离:面向接口编程

接口就是规范，定义的是一组规则，体现了现实世界中“如果你是…则必须能.….”的思想。如果你是天使，则必须能飞。如果你是汽车，则必须能跑。如果你好人，则必须干掉坏人;如果你是坏人，则必须欺负好人。接口的本质是契约，就像我们人间的法律一样。制定好后大家都遵守。
OO的精髓，是对对象的抽象，最能体现这一点的就是接口。为什么我们讨论设计模式都只针对具备了抽象能力的语言（比如c++、java、c#等)，就是因为设计模式所研究的，实际上就是如何合理的去抽象。

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

package aaa.demo03;

//interface定义的关键字，接口都需要实现类
public interface UserServicr {
//    public void run(){
//        不叫写方法实现
//    }
    public static final int age=99;     //接口中定义变量按常量算


    //接口中的所有定义的方法其实都是抽象的public abstract
    public abstract void run();

    void add(String name);
    void delete(String name);
    void update(String name);
    void query(String name);
}

package aaa.demo03;

public interface TimeService {
    void timer();
}

package aaa.demo03;

//实现了接口的类，就需要重写接口中的方法
public class UserServiceIp1 implements UserServicr,TimeService{
    @Override
    public void run() {

    }

    @Override
    public void add(String name) {

    }

    @Override
    public void delete(String name) {

    }

    @Override
    public void update(String name) {

    }

    @Override
    public void query(String name) {

    }

    @Override
    public void timer() {

    }
}

//约束
//定义一些方法，让不同的人实现
// public abstract
//public static final
//接口不能被实例化心，接口中没有构造方法
//implements可以实现多个接口
//必须要重写接口中的方法

内部类

内部类就是在一个类的内部在定义一个类，比如，A类中定义一个B类，那么B类相对A类来说就称为内部类，而A类相对B类来说就是外部类了。
1.成员内部类
⒉.静态内部类
3.局部内部类
4.匿名内部类

package aaa.demo04;

public class Outer {

    private int id=10;
    public void out(){
        System.out.println("这是外部类的方法");
    }

    public class Inter{
        public void in(){
            System.out.println("这是内部类的方法");
        }

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

package aaa;

import aaa.demo04.Outer;

public class Application {
    public static void main(String[] args) {
        Outer outer = new Outer();
        //通过这个外部类来实例化内部类~
        Outer.Inter inter = outer.new Inter();
        inter.getID();
    }
}

package aaa.demo04;

public class Outer {
    
}
//一个java类中可以有多个cLass类，但是只能有一个public class
class A{
    public static void main(String[] args) {

    }
}

package aaa.demo04;

public class Outer {
    //局部内部类
    public void method(){
        class Inner{
            public void in(){

            }
        }
    }
}

package aaa.demo04;

public class Test {
    public static void main(String[] args) {
        //没有名字初始化类，不用讲实例保存到变量中~
        new Apple().eat();

        UserServicce userServicce=new UserServicce(){
            @Override
            public void hello() {

            }
        };
    }
}
class Apple{
    public void eat(){
        System.out.println("1");
    }
}
interface UserServicce{
    void hello();
}