了解static及面向对象抽象类、接口、及内部类

static

static属性及方法

package com.oop.demo07;
//static
public class Student {
    //属性
    public static int age;//静态变量
    public double score;//非静态变量

    //方法
    public void run(){//非静态方法
        go();//非静态方法可以在方法中直接调用静态方法
    }
    public static void go(){//静态方法
        //run();静态方法中无法直接调用非静态方法
    }


    public static void main(String[] args) {
        Student s1 = new Student();
        System.out.println(Student.age);//当属性为静态变量时，可以直接使用类进行调用，该变量为类变量
        System.out.println(s1.score);//通过实例化类调用属性
        System.out.println(s1.age);//通过实例化类调用属性

        Student.go();//静态方法可以直接用类进行调用，不需要实例化
        s1.run();//非静态方法必须要实例化后才能被调用


    }

}

static代码块

package com.oop.demo07;

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();
        //静态匿名代码块 
        //匿名代码块
        //无参构造器
        Person person1 = new Person();
        //匿名代码块
        //无参构造器

    }
}

static导入包

package com.oop.demo07;
//静态导入包
import static java.lang.Math.random;
import static java.lang.Math.PI;

public class Test {
    public static void main(String[] args) {
        System.out.println(random());//使用静态导入包后，可以直接调用方法
        System.out.println(PI);//使用静态导入包后，可以直接调用方法

    }
}

抽象类

1. 是使用关键字abstract来修饰，修饰类就是抽象类，修饰方法就是抽象方法
2. 抽象类中可以没有抽象方法，但抽象方法必须存在于抽象类中
3. 抽象类不能使用new关键字来创建对象，它是由子类来继承的
4. 抽象方法只有方法的声明，没有方法是实现，它是用来由子类去实现的
5. 子类继承抽象类，就必须实现抽象类中没有实现的方法，除非该子类也为抽象类

package com.oop.demo08;
//抽象类
//abstract:在类前面加上关键字abstract就变成了抽象类
public abstract class Action {


    //这是一个约束，可以有人帮我们实现
    //abstract:用在方法上就是抽象方法，只有方法的名字，没有方法的实现
    public abstract void doSomething();
    public void run(){

    }
    /*
    1.抽象类不能new出来，只能靠子类去实现它，本质是起一个约束的作用
    2.抽象类里面可以存在普通方法
    3.抽象方法必须存在于抽象类中
    4.抽象类存在构造器
     */
    
}

package com.oop.demo08;
//子类
//抽象类中的所有抽象方法，继承它子类，必须要用方法重写来实现方法，除非继承它的子类也为抽象类
public  class A extends Action {
    public A() {
        super();//抽象类中存在构造器，可以用来初始化值，但不能被new出来
    }

    @Override
    public void doSomething() {
        
    }
    
}

接口

1. 接口就是规范，定义的是一组规则，是一个专业的约束
2. 接口的本质是契约，就像法律一样，制定好了，大家都要去遵守
3. 面向对象的精髓是对对象的抽象，最能体现这一点的就是接口
4. 声明类的关键字为：class,声明接口的关键字为：interface

package com.oop.demo09;
//接口1
//接口是使用关键字 interface 来修饰  接口都需要有实现类来实现
public interface UserService {
    //接口中定义的属性都是静态的常量值，会默认生成public static final
    int age=10;


    //接口中所有定义的方法都是抽象的，所有的方法都为抽象方法，会默认生成public abstract
    void add(String name);
    void delete(String name);
    void update(String name);
    void query(String name);

package com.oop.demo09;
//接口2
public interface TimeServica{
    void timer();

}

package com.oop.demo09;
//抽象类是使用extends,  是单继承的
//类可以是实现接口 使用关键字implements
//实现了接口的类，就需要重写接口中的方法,不能用接口去实现接口
//接口可以实现伪多继承
public class UserServicaImpl implements UserService,TimeServica {
    
    @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() {

    }
}

/*
接口
1.接口是起一个约束的作用
2.可以定义一些方法，使不同的人去实现
3.接口中的方法都是使用public abstract 进行修饰，会默认生成
4.接口红的属性都是常量，使用public static final 进行修饰，也会默认生成
5.接口不能被实例化，不能使用new关键字
6.接口不是一个类，是没有构造方法的
7.使用implements 可以实现多个接口，相当于实现了Java中伪的多继承
8.实现接口必须要重写里面的方法
 */

内部类

• 内部类就是在一个类的内部再定义一个类

成员内部类

package com.oop.demo10;

public class Outer {
    private int id=1001;
    private void run(){
        System.out.println("run");
    }
    public void out(){
        System.out.println("这是外部类的方法");
    }
    public class Inner{
        //这是成员内部类
        public void in(){
            System.out.println("这是内部类的方法");
        }
        //可以获得外部类的私有属性及方法
        public void id(){
            System.out.println(id);
            run();
        }

    }

}

package com.oop;


import com.oop.demo10.Outer;

public class Application {
    public static void main(String[] args) {
        Outer outer = new Outer();
        outer.out();//这是外部类的方法
        Outer.Inner inner = outer.new Inner();
        inner.in();//这是内部类的方法
        inner.id();//1001  run


    }
}

局部内部类

package com.oop.demo10;

public class Test1 {
    public void outer(){
        //局部内部类
        class Inner{
            public void in(){
                System.out.println("这是局部内部类");
            }
        }
       new Inner().in();
    }
}

package com.oop;


import com.oop.demo10.Outer;
import com.oop.demo10.Test1;

public class Application {
    public static void main(String[] args) {
        Test1 test1 = new Test1();
        test1.outer();//这是局部内部类

    }
}

匿名内部类

package com.oop.demo10;

public class Test2 {
    public static void main(String[] args) {
        //匿名内部类
        //没有名字，直接初始化类，不用减变量保存到变量中
        new Apple().eat();//1
    }
}



//一个Java类中可以有多个class类，但只能有一个public class
class Apple{
    public void eat(){
        System.out.println("1");
    }
}