面向对象04

文章	评论	标签
77	5	5

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(s1.score);
        System.out.println(s1.age);//通过对象调用

        System.out.println(Student.age);//通过类调用
        System.out.println(Student.score);//此行编译报错，非静态static属性，不可直接使用类名调用变量
    }
}

若类的属性定义时有static，则推荐使用类直接调用属性变量

静态变量对类而言在内存中只存在一个，唯一的，其可以被实例对象所共享。

对方法而言，若带static，静态方法，通过类即可调用：

public class Student {

    public void run(){
        //非静态方法
        go();//或Student.go()；
    }
    public static void go(){
        //静态方法
    }

    public static void main(String[] args){
        Student.go();//可行
        Student.run();//编译报错
        
        Student s1 = new Student();
        s1.run();//可行
    }
}

即：static静态方法可以直接通过类名进行调用，而非静态方法需要通过创建实例对象，再通过实际对象进行调用。且非静态方法中，可以调用非静态方法。静态方法中可以调用静态方法，但不可调用非静态方法。

（static的方法在加载时会跟类一起加载，而非静态方法在加载时并未加载，因此static方法可以直接调用，而非静态方法不行）

静态代码块

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();
        System.out.println("========================");
        Person person1 = new Person();
    }
}
输出：
静态代码块
匿名代码块
构造方法
========================
匿名代码块
构造方法

静态代码块在类加载时一同加载，帮助初始化一些数据，且只执行一次

static{
}


public class Test {
    public static void main(String[] args) {
        System.out.println(Math.random());//Math类的random方法
    }
}
0.688664170417222

静态导入包：可省略类名直接通过方法() 调用方法

 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);
    }
}

final是常量的修饰符：通过final修饰的类不能被继承，没有子类

public final class Person {
    
}

public class Student extends Person{
    //会报错，因为Person通过final修饰，不可被继承
}

抽象类

通过abstract修饰的类

抽象类的所有方法，必须由继承它的子类来实现，除非子类也是abstract（则子类的子类来实现）（子承父业，但全是借条，需要子类来还债）

子类只需要实现抽象类的父类的抽象方法即可

public abstract class Action {//抽象类

    //假设方法只是个约束，里面没有内容，最好由别人代替实现（大型框架中写约束）
    //public void doSomething(){ }

    
    public abstract void thing();//抽象方法：只有方法名字，没有方法实现，子类代替实现

}


    public class A extends Action{
        //继承了抽象类父类的子类，需要实现父类抽象类中的抽象方法
        @Override
        public void thing() {
            //通过重写父类中的抽象方法来实现抽象方法
        }
    }

extends是单继承：没办法继承多个类，有局限性；

接口可以帮助实现多继承。（插座）

抽象类特点：

不能new抽象类，只能靠子类来实现，（仅是一个约束，类比与法律）
一旦由抽象方法，那类一定需要是抽象类，但抽象类中也可以有普通方法
可扩展性高。

Java接口定义与实现

接口不使用class定义

普通类：只有具体实现

抽象类：具体实现和规范（抽象方法）都有

接口：只有规范，抽象的抽象，专业的约束，约束和实现的分离。公司：面向接口编程。

接口就是规范，定义的是一组规则，体现了现实中的“如果你是xx则必须xx”。

接口的本质是契约，如同法律，制定好后都遵守

OOP的精髓：对对象的抽象，最能体现这一点的即接口

声明类的关键字：class

声明接口的关键字：interface

public interface UserService {//声明一个接口
    
   //public void run(){
      //写具体方法会报错  
    //}
    
}


public interface UserService {
    void run();//方法的简单实现可以，不能有方法体
}

接口中不能写方法的实现，且接口中所有定义的方法都是抽象的且public 的

public interface UserService {
    public abstract void run();
    void run();//这两行效果一样，默认都是public abstract
    void go(int S);
}

接口都需要有其对应的实现类

且其对应的实现类命名方式：接口名Impl

implement（实现）

声明方式：public class 接口名Impl implements 接口名{}

public interface UserService {
    void add(String name);
    void delete(String name);
    void update(String name);
    void query(String name);
}//接口



//抽象类：通过extends单继承
//类可以实现接口，通过implements声明，并在类中进行接口所有方法的重写


public class UserServiceImpl implements UserService{
//实现接口的类需要对接口中的所有方法重写
    @Override
    public void add(String name) {

    }

    @Override
    public void delete(String name) {

    }

    @Override
    public void update(String name) {

    }

    @Override
    public void query(String name) {

    }
}

伪多继承

接口可以多“继承”：一个类可以implements多个不同接口，即一个类可以同时实现不同的接口：

public interface UserService {
    void add(String name);
    void delete(String name);
    void update(String name);
    void query(String name);
}

public interface TimeService {
    void Timer();
}

public class UserServiceImpl implements UserService,TimeService{
    //此处即多实现，即通过接口实现的多继承
    
    //实现接口的类需要对接口中的所有方法重写
    @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() {

    }
}

总之：接口中只有方法的定义，通过interface定义接口，而类中进行（多个）接口所有方法的实现

接口中也可定义常量/变量

接口中所有定义的属性都默认是public static final的，公共+静态+常量

public interface UserService {

    public static final int AGE = 99;
    int AGE = 99;
    //两行效果一致
}

接口核心：写方法并通过类实现

难点：抽象思维→架构师

接口总结：

1.约束
2.定义一些方法，让不同的人实现，即同一类方法交给不同的人有不同的具体实现
3.接口方法：public abstract
4.接口常量：public static final
5.接口不能被实例化（类比于类实例化成对象）：不可以new接口，接口中也没有构造方法
6.接口在通过类implement实现时，可以一个类实现多个接口
7.类在实现接口时，必须重写接口中的方法

将所有东西接口化，将方法逐一实现。