Java学习笔记(十)

第7章面向对象(下)

7.1 静态的

1、static：静态的
2、什么是静态的？
和对象无关的，不会因为对象的不同而不同，即所有对象都一样的。
换句话说，和对象无关。
动态的，根据对象的不同而不同，和对象有关，由对象动态决定。
3、static这个关键字用在哪里？
（1）成员变量前面：静态变量
（2）成员方法前面：静态方法
（3）代码块前面：静态代码块
（4）内部类class前面（后面和内部类一起讲）：静态内部类
（5）在import语句里面：静态导入

7.1.1 静态变量

4、静态变量
（1）静态变量的定义：是指有static修饰的成员变量
（2）静态变量的特点：
A：静态变量的值是所有对象共享的。
B：虽然可以，但不建议通过“对象.静态变量”的形式进行访问，
建议通过“类名.静态变量”的形式进行访问。
C：如果静态变量的可见性范围被限制了，提供get/set时，它的get/set也是静态的。
在set方法中，静态变量和局部变量（形参）重名了，使用“类名.静态变量”进行区分。
D：静态变量的值是存储在“方法区”中。

//Company公司
public class Employee {
    public static String company;//静态变量
    public String name;//实例变量
    private static String corporation;

    public static String getCorporation() {
        return corporation;
    }

    public static void setCorporation(String corporation) {
        Employee.corporation = corporation;
        //不能使用this.
    }
}

public class TestStaticVariable {
    public static void main(String[] args) {
        Employee e1 = new Employee();
        Employee e2 = new Employee();
        e1.company = "执影";

        System.out.println(e1.company);
        System.out.println(e2.company);
//        System.out.println(Employee.company);

        e2.company = "zhiying";

        System.out.println(e1.company);
        System.out.println(e2.company);

        System.out.println("-----------------");
        //静态变量推荐使用“类名.静态变量”的形式进行访问。
        Employee.company = "执影人";
        System.out.println(Employee.company);
    }
}

7.1.2 静态方法

5、静态方法
（1）静态方法的定义：是指有static修饰的方法。
（2）静态方法的特点：
A：静态方法中不允许直接使用本类的非静态成员
B：静态方法中也不允许直接使用this,super等关键字
C：静态方法的调用虽然可以用“对象.静态方法”的形式进行访问，
但是我们更推荐“类名.静态方法”的形式进行访问。
D：父类的静态方法可以被子类访问，但是不能被子类重写

public class Student {
    private static String school;
    private String name;
    public static String getSchool(){
        return school;
    }
    
    public static void method(){
        System.out.println(this.name);//错误，静态方法中不允许出现this
        System.out.println(name);//错误，静态方法中不允许直接访问非静态的实例变量name
        System.out.println(super.hashCode());//错误，静态方法也不允许出现super
    }
}

public class TestStudent {
    public static void main(String[] args) {
        System.out.println(Math.random());

        Student stu = new Student();
        System.out.println(stu.getSchool());
        //编译器也会处理成Student.getSchool()
        System.out.println(Student.getSchool());
    }
}

public class Father {
    public static void method(){
        System.out.println("Father.method");
    }
}

/*
@Override：是一个注解。
作用：和编译器说，它标记的方法是子类重写父类的方法。请“严格”按照重写的要求进行格式检查。
如果违反重写的要求，就编译报错。

如果一个方法遵守重写的要求，加或不加@Override都可以。
如果一个方法没有遵守重写的要求，不加@Override有可能编译器不提示你错误，导致和你的意图不一致。

 建议：凡是重写的方法，不管你写的对不对，都加@Override。

 */
public class Son extends Father {

    //自己以为我重写成功了，但是其实是不对的
   /* public static void method(){
        System.out.println("Son.method");
    }*/
}

public class TestSon {
    public static void main(String[] args) {
        Father f = new Son();
        f.method();//完全等价于Father.method

        Father.method();
        Son.method();
    }
}

7.1.3 静态代码块

6、静态代码块
（1）静态代码块的作用：为类的静态变量初始化
（2）静态代码块的执行特点
A：一个类的静态代码块只会执行一次
B：它是在类加载类初始化时执行，先于类对象的创建
（3）语法结构
【修饰符】 class 类名{
static{
静态代码块

public class Demo {
    static {
        System.out.println("静态代码块");
    }

    public Demo(){
        System.out.println("Demo无参构造");
    }
}

public class TestDemo {
    public static void main(String[] args) {
        Demo d1 = new Demo();
        Demo d2 = new Demo();
    }
}

7.1.4 类初始化

7、类初始化
（1）类初始化：为类的静态变量赋值的过程
（2）类初始化相关代码
A：静态变量声明时，直接=值
B：静态代码块
（3）如果我们编写了类初始化相关代码，那么编译器会给我们
把这些代码按照编写顺序组装到一个<clinit>()的类初始化方法中。
cl：class
init：initialize
（4）一定是先完成类初始化，再进行实例初始化（创建对象），
并且一定是先完成父类初始化，再完成子类初始化。

public class SubDemo extends Demo {
    static {
        System.out.println("子类SubDemo的静态代码块");
    }
}

public class TestDemo {
    public static void main(String[] args) {
        /*Demo d1 = new Demo();
        Demo d2 = new Demo();
*/
        SubDemo s1 = new SubDemo();
        SubDemo s2 = new SubDemo();
    }
}

7.1.5 静态导入

8、静态导入
（1）静态导入的定义：在import语句里面出现static，就是静态导入
（2）作用：在当前的.java文件中，使用另一个类的静态成员时，可以直接在代码中使用静态成员名，而不用“类名.静态成员名。

import static java.lang.Math.*;

public class TestStaticImport {
    public static void main(String[] args) {
        /*System.out.println(Math.PI);
        System.out.println(Math.random());
        System.out.println(Math.sqrt(9));*/

        System.out.println(PI);
        System.out.println(random());
        System.out.println(sqrt(9));
    }
}

7.2 抽象类和抽象方法

1、什么是抽象类？
在class前面加abstract修饰的都是抽象类。
【其他修饰符】 abstract class 类名{
2、为什么要用抽象类？
（1）不希望你创建这个类的对象，希望你创建它子类的对象（少一点）
（2）当我们在声明某个父类时，其中某些方法不得不声明，但是又无法给出具体的实现，
即无法编写方法体代码，这个方法体代码通常由子类来实现，各个子类的实现不同，
这个时候需要把这样的方法声明为抽象方法，
Java中包含抽象方法的类必须是抽象类（更多的情况）。
3、抽象类的特点
（1）抽象类不能直接new对象，只能new它子类的对象
（2）抽象类中可以包含抽象方法，也可以不包含抽象方法。
但是反过来，包含抽象方法的类，必须是抽象类。
（3）抽象类是用来被继承的，子类继承抽象类时，必须重写抽象类的所有抽象方法，
否则子类也得是抽象类。
4、抽象类和非抽象类有什么区别？
抽象类不能直接new对象，非抽象类可以直接new对象，
抽象类中可以包含抽象方法，非抽象类中不可以包含抽象方法。
5、抽象类中有构造器吗？
它的构造器存在的意义是被子类调用的。

public abstract class Person {
    private String name;
    private int age;

    public Person(){
    }

    public Person(String name, int age) {
        this.name = name;
        this.age = age;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

    @Override
    public String toString() {
        return "Person{" +
                "name='" + name + '\'' +
                ", age=" + age +
                '}';
    }
}

public class Student extends Person {
    //....
}

public class Teacher extends Person {
    //.....
}

public class TestPerson {
    public static void main(String[] args) {
        //做学生信息管理系统
        //在整个系统中，要么存在的是学生对象，要么存在的是教师对象
        //希望整个程序中不能直接new Person的对象。
        Person[] arr = new Person[3];
//        arr[0] = new Person();//报错，因为抽象类不允许直接new对象
        arr[1] = new Student();
        arr[2] = new Teacher();
    }
}

//包含抽象方法的类必须是抽象类
public abstract class Graphic {
    /*public double area(){
        return 0.0;
    }*/

    //抽象方法，没有方法体，有abstract修饰
    public abstract double area();
}

public  class Circle extends Graphic {
    private double radius;

    public Circle() {
    }

    public Circle(double radius) {
        this.radius = radius;
    }

    public double getRadius() {
        return radius;
    }

    public void setRadius(double radius) {
        this.radius = radius;
    }

    @Override
    public String toString() {
        return "Circle{" +
                "radius=" + radius +
                '}';
    }

	//不重写报错
    @Override
    public double area() {
        return Math.PI * radius * radius;
    }
}

public class Rectangle extends Graphic{
    private double length;
    private double width;
    public Rectangle(){
    }

    public Rectangle(double length, double width) {
        this.length = length;
        this.width = width;
    }

    public double getLength() {
        return length;
    }

    public void setLength(double length) {
        this.length = length;
    }

    public double getWidth() {
        return width;
    }

    public void setWidth(double width) {
        this.width = width;
    }

    @Override
    public String toString() {
        return "Rectangle{" +
                "length=" + length +
                ", width=" + width +
                '}';
    }
    //不重写报错
	@Override
    public double area(){
        return length * width;
    }
}

public class TestGraphic {
    public static void main(String[] args) {
        Graphic[] arr = new Graphic[2];
        arr[0] = new Circle(2.5);
        arr[1] = new Rectangle(5,3);
        for (int i = 0; i < arr.length; i++) {
            System.out.println(arr[i].area());
            /*
            arr[i]的编译时是Graphic类型，先要去Graphic类中匹配area()方法，
            此时Graphic类中没有area()方法，编译报错。
            为了编译通过，必须在Graphic类中，增加area()方法
             */
        }
    }
}

7.3 注解

7.3.1 基本注解

1、什么是注解？
在代码中，使用@开头的都是注解。
2、注解有什么用呢？
注解也是一种注释，这种注释是代码级别的注释，
它是让另一段代码来读取这个注解，并做出相应的xx操作。
例如：@Override注解。
当编译器（编译器也是一段程序）读取到某个方法上面加了@Override，
就会执行一段代码，这段代码是一段校验该方法是否满足重写要求的判断代码，
如果满足，那么编译通过，
如果不满足，编译器会报错，提醒你违反了重写的要求。
3、3个最最基本的系统注解（JDK1.8之前就有的）
（1）@Override注解
它只能加在重写的方法上面。
（2）@Deprecated注解
它可以用在方法、类、构造器等等上面。
作用：让编译器提醒程序员，如果你使用了这个方法、类、构造器等，编译器会弹出警告，
提醒你这个方法、类、构造器等已经过时了，可能存在设计的缺陷，或者其他问题，
不再推荐你继续使用。
为什么已过时的代码不修复或删掉呢？
修复：修复的成本太高，重新设计一个
开发原则：面向修改关闭，面向扩展开发
删掉：因为这些方法、类、构造器等在旧的项目中还在使用。
注销银行卡。
不会删除你之前的所有的银行记录啥，
而是标记为这个卡不能用。
这个操作称为逻辑删除，不是物理删除。
（3）@SuppressWarnings

import java.util.Date;

public class TestDeprecated {
    @SuppressWarnings("all")
    public static void main(String[] args) {
        Date today = new Date(2022-1900,8-1,20);
        //使用这个构造器时Date(int year, int month, int date)
        //编译器会弹出警告，说，这个方法已过时
        System.out.println(today);
        //Wed Sep 20 00:00:00 CST 3922
    }
}

7.3.2 文档注释

1、Java中有3种注释
（1）单行注释 //
（2）多行注释 /* */
（3）文档注释/** */
文档注释有严格的格式要求。

/**
 * 文档注释演示类
 * @author Irene
 * @version JDK1.8
 * @see java.lang.Object
 */
public class TestDoc {
    /**
     * 这是一个主方法，Java程序的入口
     * @param args String[] 它是命令行参数，可以通过java命令传入参数值。格式：java 主类名 参数值1 参数值2 ...
     */
    public static void main(String[] args) {
        //...
    }

    /**
     * 这是一个求两个整数最大值的方法
     * @param a int 第一个整数
     * @param b int 第二个整数
     * @return int 当a大于b时，返回a的值，否则返回b的值
     */
    public static int max(int a, int b){
        return a > b ? a : b;
    }

    /**
     * 这是求两个整数的商。
     * @param a int 被除数
     * @param b int 除数
     * @return int 商，a/b的结果，只有整数部分
     * @exception ArithmeticException 当b为0时可能发生算术异常
     */
    public static int divide(int a, int b){
        return a/b;
    }
}

7.3.3 JUnit

说明：标准的单元测试编写方式，在实际项目中再讲。
今天，讲单元测试的JUnit的小工具只是把它当成一个代替main方法运行的小工具而已。
使用步骤：
（1）在当前模块中要引入JUnit的库
因为JUnit不是JRE核心类库的一部分，它是第三方的一个工具。
引入的方式很简单：
第一步：先写一个方法
第二步：在方法上面加一个@Test
第三步：@Test会报错，鼠标放到@Test上面，IDEA会提示我们需要引入JUnit的库（一堆class文件）
第四步：单击Add 'JUnit4' to classpath
第五步：下载，默认是下载到C盘用户目录下的.m2的仓库中
（至于后期项目中如何依赖和下载，咱们学习Maven时再学习）
（2）凡是要独立运行的测试方法上面都可以加@Test
使用要求：
（1）自己写的类名，同一个包的所有类，包括当前类，不能命名为Test类。
（2）要使用@Test标记测试方法，
这个测试方法必须是public，void，()，非静态的
（3）@Test标记的测试方法所在类必须只有唯一的无参构造，并且也是public的。

import org.junit.Test;

public class TestJUnit {
    @Test
    public void test01(){
        System.out.println("hello");
    }

    @Test
    public void test02(){
        System.out.println("world");
    }
}

第7章面向对象(下)

7.1 静态的

7.1.1 静态变量

7.1.2 静态方法

7.1.3 静态代码块

7.1.4 类初始化

7.1.5 静态导入

7.2 抽象类和抽象方法

7.3 注解

7.3.1 基本注解

7.3.2 文档注释

7.3.3 JUnit

Recommend

AWS AppSync now supports JavaScript for all resolvers in GraphQL APIs

Integration Testing

一文学会链表双指针技巧

Self Improvement Pack

大股东闪崩！中融信托澄清了，又像没澄清

Qwikify your Development with Nx

10 Best Free VPN Services in 2023

VibeHunt - Get recommendations by vibes, not literal words | Product Hunt

GitHub - CleytonBonamigo/share-twitter: PHP Version to post a new twitter

OpenAI 宣布创立以来首笔公开收购；小鹏否认收购玛莎拉蒂；特斯拉改进版 Model3 下月...

About Joyk

Java学习笔记(十)

第7章 面向对象(下)

7.1 静态的

7.1.1 静态变量

7.1.2 静态方法

7.1.3 静态代码块

7.1.4 类初始化

7.1.5 静态导入

7.2 抽象类和抽象方法

7.3 注解

7.3.1 基本注解

7.3.2 文档注释

7.3.3 JUnit

Recommend

About Joyk

第7章面向对象(下)