static总结,抽象

static总结

package com.oop.demo07;
//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();
        new Student().run(); //非静态方法不能用类直接输出
    }
}

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();//静态代码块
                                     //匿名代码块
                                     //构造方法
        System.out.println("===========");
        Person person1 = new Person();//匿名代码块
                                     // 构造方法,静态代码块只运行一次
    }
}

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

抽象

package com.oop.demo08;
//abstract 抽象类  类extend：单继承  （接口可以多继承）
public  abstract class Action {

    //约束，有人帮我们实现
    //abstract，抽象方法，只有方法名字，没有方法的实现
    public abstract void doSomething();、
    //1.不能new这个抽象类，只能靠子类去实现它：约束
    //2.抽象类中可以写普通方法
    //3.抽象方法必须在抽象类中
    //抽象的抽象：约束
}
================
    package com.oop.demo08;
//抽象类的所有方法，继承了它的子类，都必须要实现它的方法，除非子类也抽象
public class A extends Action{
    @Override
    public void doSomething() {

    }
}

约束

在Java中，约束是一种规则，用于限制表中列上的数据，保证数据的完整性和一致性。例如，约束可以指定某列不能为空，或者某列的值必须唯一，或者某列的值必须符合某种格式等。

约束也可以用于强制方法体满足一些不变量或限制，例如不执行任何I/O操作，或者只调用已知的类的方法等。 这样可以保证方法的安全性和正确性。Java语言本身没有提供直接的方式来检查或强制这些约束，但是可以通过一些技术来实现，例如使用注解，枚举，自定义注解处理器或域特定语言等。

Java抽象类 有构造器吗

是的，Java抽象类可以有构造器。 抽象类的构造器通常用于初始化父类中的成员变量，并在子类中被继承。抽象类中的构造器不能被实例化，只能通过其子类来调用。 在 Java 中，抽象类可以有多种类型的构造器，例如：无参构造器、带参构造器等。 抽象类的构造器在子类中通过 super 关键字调用。

​ 例如，下面的代码定义了一个抽象类 Animal，它有一个私有的 name 属性和一个带参的构造器来初始化这个属性。另外，Animal 类中还有一个非抽象的方法 getName()，它可以被所有的子类继承并使用。而 eat() 方法是一个抽象方法，没有具体的实现，需要子类去实现。

public abstract class Animal {
  private String name;
  public Animal (String name) {
    this.name = name;
  }
  public String getName () {
    return name;
  }
  public abstract void eat ();
}

Cat 类继承了 Animal 类，并实现了 eat() 方法。注意，在 Cat 类中，必须实现 eat() 方法，否则编译器会报错。同时，在 Cat 类的构造器中，必须调用 super(name) 来调用父类的构造器。

public class Cat extends Animal {
  public Cat (String name) {
    super (name);
  }
  public void eat () {
    System.out.println (getName () + " likes to eat fish.");
  }
}

Java抽象类存在的意义

Java抽象类存在的意义是为了被子类继承，体现了模板思想和多态性。 抽象类可以定义一些公共的方法和属性，但是这些方法没有具体的实现，需要子类去实现。 抽象类也可以定义一些抽象方法，只有方法名而没有方法体，强制子类去重写这些方法。 抽象类不能被实例化，只能通过其子类的引用来创建对象。

抽象类的意义在于将设计和实现分离，让子类根据自己的需求来实现父类的抽象方法，提高了程序的可扩展性和可维护性。 抽象类也可以将一些具有相同属性和方法的具体概念进行抽象，减少代码的重复和冗余。