CT的Java基础学习笔记（七）——面向对象（下）

最新推荐文章于 2023-01-26 20:47:33 发布

MousseCaketao

最新推荐文章于 2023-01-26 20:47:33 发布

阅读量133

点赞数

分类专栏： Java SE 文章标签： java

本文链接：https://blog.csdn.net/CTtao123/article/details/110841982

版权

Java SE 专栏收录该内容

16 篇文章 0 订阅

订阅专栏

Java基础学习笔记整理了我从零开始学习Java时所学习到的内容。
以下内容参考尚硅谷Java教程。

七、面向对象（下）

1 关键字static的使用

主要用来修饰类的内部结构：属性、方法、代码块、内部类

1.1 修饰属性：静态变量（或类变量）

按是否使用static修饰。分为：静态属性 vs 非静态属性（实例变量）

实例变量:我们创建了类的多个对象，每个对象都独立的拥有一套类中的非静态属性当修改其中一个对象中的非静态属性时，不会导致其他对象的同样的属性值的修改。
静态变量：我们创建了类的多个对象，多个对象共享同一个静态变量。当通过某一个对象修改静态变量时，会导致其他对象调用此静态变量时，是修改过了的。
说明：

静态变量随着类的加载而加载，可以通过"类.静态变量"的方式进行调用；
静态变量的加载早于对象的创建。
由于类只会加载一次，则静态变量在内存中只会存在一份：存在方法区的静态域中

举例：System.out、Math.PI

1.2 修饰方法：静态方法

随着类的加载而加载，可以通过"类.静态方法"的方式进行调用；
静态方法中，只能调用静态方法与属性。

注意点：在静态方法内，不能使用this关键字、super关键字

1.3 如何判定属性和方法是否应该使用static关键字

属性：属性是可以被多个对象所共享的，不会随着对象的不同而不同的
类中的常量也常常定义为static的
方法：操作静态属性的方法，通常设置为static的
工具类中的方法，习惯上声明为static的

1.4 使用举例

Arrays、Math、Collection等工具类
单例模式
自己写的

class Circle{
    private double radius;
    private int id;

    public Circle(){
        id = init++;
        total++;
    }
    public Circle(double radius){
        this();
        this.radius = radius;
    }

    private static int total;
    private static int init = 1001;

    public double findArea(){
        return Math.PI*radius*radius;
    }

    public int getId() {
        return id;
    }

    public static int getTotal() {
        return total;
    }
}

2 类的成员之四：代码块

2.1 代码块的作用

用来初始化类、对象的信息

2.2 分类

代码块使用修饰符只能用static

静态代码块 vs 非静态代码块

静态代码块：

内部可以有输出语句
随着类的加载而执行,而且只执行一次
初始化类的信息
如果一个类中定义了多个静态代码块，根据声明先后顺序执行

非静态代码块：

内部可以输出语句
随着对象的创建而执行
没创建一个对象,就执行一次非静态代码块
作用:可以在创建对象时,对对象的属性等进行初始化

3 关键字final的使用

可以用来修饰：类、方法、变量

final修饰类时表明该类不能被其他类所继承，比如：String类、System类
final修饰方法时表明该方法不能被重写
final修饰变量时：此时变量就被称为一个常量
修饰属性：可以考虑赋值的位置
修饰局部变量：修饰形参时，表明该形参为一个常量。当我们调用该方法时给该形参一个实参，在方法体内该形参就不能被修改

补充：static final 全局常量

4 抽象类与关键字abstract的使用

abstract：抽象的
abstract可以用来修饰的结构：类、方法

修饰类：抽象类

此类不能实例化。
抽象类中一定有构造器，便于子类实例化的时候使用。
开发中，都会提供抽象类的子类，让子类完成实例化，完成相关操作。

修饰方法：抽象方法

抽象方法只有方法的声明，没有方法体。
包含抽象方法的类一定是一个抽象类。然而，抽象类中可以没有抽象方法。
若子类重写了父类中的所有抽象方法，此子类才可以实例化；
若子类没有重写完父类中的所有抽象方法，则此子类也是抽象类，需要使用abstract。

注意点：

abstract不能用来修饰：属性、构造器等结构
abstract不能用来私有方法、静态方法、final方法、final的类

5 接口与关键字interface的使用

接口使用interface来定义
在Java中，类和接口是并列的两个结构
如何定义接口：定义接口中的成员，JDK7以前只能定义全局常量与抽象方法；JDK8以后可以定义静态方法、默认方法
接口中不能定义构造器，意味着接口不能被实例化
Java开发中，接口通过让类去实现implements的方式来使用。
Java类可以实现多个接口
接口与接口之间可以继承，而且可以多继承
接口的使用，体现多态性
接口，实际上可以看作一种规范

举例：

public class USBTest {
    public static void main(String[] args) {
        Computer com = new Computer();

        //1.创建了接口的非匿名实现类的非匿名对象
        Flash flash = new Flash();
        Printer printer = new Printer();
        com.transferData(flash);
        System.out.println("************************");
        com.transferData(printer);

        //2.创建了接口的非匿名实现类的匿名对象
        System.out.println("************************");
        com.transferData(new Printer());

        //3.创建了接口的匿名实现类的非匿名对象
        System.out.println("************************");
        USB phone = new USB() {
            @Override
            public void start() {
                System.out.println("手机开始工作");
            }

            @Override
            public void stop() {
                System.out.println("手机停止工作");
            }
        };
        com.transferData(phone);

        //4.创建了接口的匿名实现类的匿名对象
        System.out.println("************************");
        com.transferData(new USB() {
            @Override
            public void start() {
                System.out.println("MP3开始工作");
            }

            @Override
            public void stop() {
                System.out.println("MP3停止工作");
            }
        });


    }
}

class Computer{
    public void transferData(USB usb){
        usb.start();
        System.out.println("details");
        usb.stop();
    }
}

interface USB{

    void start();

    void stop();
}

class Flash implements USB{
    @Override
    public void start() {
        System.out.println("U盘开始工作");
    }

    @Override
    public void stop() {
        System.out.println("U盘停止工作");
    }
}

class Printer implements USB{
    @Override
    public void start() {
        System.out.println("打印机开始工作");
    }

    @Override
    public void stop() {
        System.out.println("打印机停止工作");
    }
}

5.1 面向接口编程

我们在应用程序中，调用的结构都是JDBC定义的接口，不会出现具体某一个厂商的API。

5.2 规范

接口中定义的静态方法只能通过接口来调用。
通过实现类的对象，可以调用接口中的默认方法。
如果子类（或实现类）继承的父类和实现的接口中声明了同名同参数的方法。那么子类在没有重写此方法的情况下，优先调用父类中的同名同参数方法–>类优先。
如果实现类实现了多个接口，而多个接口中定义了同名同参数的默认方法，那么在实现类没有重写此方法的情况下，报错–>接口冲突。所以必须在实现类中重写。

6 类的成员之五：内部类

6.1 定义

Java中允许将一个类A声明在另一个类B中，则类A就是内部类，类B称为外部类

6.2 分类

成员内部类 VS 局部内部类

成员内部类：
一方面，作为外部类的成员：

调用外部的结构。
可以被static修饰。
可以被4种不同的权限修饰。

另一方面，作为一个类：

类内可以定义属性、方法、构造器等。
可以被final修饰，表示此类不能被继承，反之，不使用final，就可以被继承。
可以被abstract修饰。

class Person{
    String name = "Person";

    public void eat(){
        System.out.println("Person eat");
    }
    //成员内部类:
    //静态
    static class Hand{
        String name;

        int length = 10;

        void show(){
            System.out.println("applaud!!");

        }
    }
    //非静态
    class Brain{
        String name = "Brain";

        void think(){
            System.out.println("thinking");
            //Person.this.eat();
        }
        public void display(String name){
            System.out.println(name);//方法形参
            System.out.println(this.name);//Brain的属性name
            System.out.println(Person.this.name);//外部类的属性name
        }
    }