Java基础系列（7）- 面向对象（下）

static关键字

当我们编写一个类时，其实就是在描述其对象的属性和行为，而并没有产生实质上的对象，只有通过new关键字才会产生出对象，这时系统才会分配内存空间给对象，其方法才可以供外部调用。我们有时候希望无论是否产生了对象或无论产生了多少对象的情况下，某些特定的数据在内存空间里只有一份

1、static：静态的

2、static可以用来修饰：属性、方法、代码块，内部类

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

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

实例变量：我们创建了类的多个变量，每个对象都独立的拥有一套类中的非静态属性。当修改其中一个对象中的非静态属性时，不会导致其他对象中同样的属性值的修改。

静态变量：我们创建了类的多个对象，多个对象共享同一个静态变量。当通过某一个对象修改静态变量时，会导致其他对象调用此静态变量时，是修改过了的

public class StaticTest {
    public static void main(String[] args){
        Chinese c1 = new Chinese();
        c1.name = "姚明";
        c1.age = 40;
        c1.nation = "Chinese";

        Chinese c2 = new Chinese();
        c2.name = "马龙";  # 和c1独立
        c2.age = 30;   # 和c1独立
        c2.nation = "China";  # 改变了c1的nation


        System.out.println((c2.nation));
    }
}


class Chinese {
    String name;
    int age;
    static String nation;
}

static 修饰属性的其他说明

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

static修饰方法：静态方法

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

static注意点

在静态的方法内，不能使用this关键字、super关键字
关于静态属性和静态方法的使用，大家都从生命周期的角度去理解。

属性和方法是否应该static

对于属性：

属性是可以被多个对象所共享的，不会随着对象的不同而不同的
类中的常量也常常声明为static

对于方法：

操作静态属性的方法，通常设置为static的
工具类中的方法，习惯上声明为static的。比如：Math、Arrays、Collections

理解main() 方法的语法

main()方法的使用说明

main() 方法作为程序的入口
main() 方法也是一个普通的静态方法
main() 方法可以作为我们与控制台交互的方式。（之前，使用Scanner）

由于main作为程序的入口，所以调用main的时候肯定出了这个class或者包，所以要public权限。

调用的时候还没有创建对象，所以要static

没有返回值，所以是void

public class MainTest {
    public static void main(String[] args) {//入口
        Main.main(new String[100]); //可以当作普通的静态方法调用
    }
}

class Main {
    public static void main(String[] args) {
        for (int i = 0; i < args.length; i++) {
            args[i] = "args_" + i;
            System.out.println(args[i]);
        }
    }
}

代码块（或初始化块）

代码块的作用：用来初始化类、对象
代码块如果有修饰的话，只能使用static
分类：静态代码块 vs 非静态代码块

静态代码块

内部可以有输出语句
随着类的加载而执行（不用调用直接执行，static方法还得类.方法才能执行），而且只执行一次
作用：初始化类的信息
如果一个类中定义了多个静态代码块，则按照声明的先后顺序执行
静态代码块的执行要优先于非静态代码块的执行
静态代码块内只能调用静态的属性、静态的方法，不能调用非静态的结构

非静态代码块

内部可以有输出语句
随着对象的创建而执行
每创建一个对象，就执行一次非静态代码块
作用：可以在创建对象时，对对象的属性等进行初始化
如果一个类中定义了多个非静态代码块，则按照声明的先后顺序执行
非静态代码块内可以调用静态的属性、静态的方法，或非静态的属性、非静态的方法

执行顺序

package com.company;
class Root{
    static{
        System.out.println("Root的静态初始化块");
    }
    {
        System.out.println("Root的普通初始化块");
    }
    public Root(){
        System.out.println("Root的无参数的构造器");
    }
}
class Mid extends Root{
    static{
        System.out.println("Mid的静态初始化块");
    }
    {
        System.out.println("Mid的普通初始化块");
    }
    public Mid(){
        System.out.println("Mid的无参数的构造器");
    }
    public Mid(String msg){
        //通过this调用同一类中重载的构造器
        this();
        System.out.println("Mid的带参数构造器，其参数值："
                + msg);
    }
}
class Leaf extends Mid{
    static{
        System.out.println("Leaf的静态初始化块");
    }
    {
        System.out.println("Leaf的普通初始化块");
    }
    public Leaf(){
        //通过super调用父类中有一个字符串参数的构造器
        super("尚硅谷");
        System.out.println("Leaf的构造器");
    }
}
public class LeafTest{
    public static void main(String[] args){
        new Leaf();
        System.out.println(); // 空一行
        new Leaf();
    }
}
>>>
Root的静态初始化块
Mid的静态初始化块
Leaf的静态初始化块
Root的普通初始化块
Root的无参数的构造器
Mid的普通初始化块
Mid的无参数的构造器
Mid的带参数构造器，其参数值：尚硅谷
Leaf的普通初始化块
Leaf的构造器

Root的普通初始化块
Root的无参数的构造器
Mid的普通初始化块
Mid的无参数的构造器
Mid的带参数构造器，其参数值：尚硅谷
Leaf的普通初始化块
Leaf的构造器

属性赋值的先后顺序

默认初始化
显式初始化/在代码块中赋值
构造器中初始化
有了对象以后，可以通过"对象.属性"或"对象.方法"的方式，进行赋值

final 关键字

final：最终的

final可以用来修饰的结构：类、方法、变量

final 用来修饰一个类：此类不能被其他类所继承，比如：String类、System类、StringBuffer类
final 用来修饰方法：表明此方法不可以被重写，比如：Object类中的getClass()；
final 用来修饰变量：此时的"变量"就被称为是一个常量
1. final 修饰属性：可以考虑赋值的位置有：显式初始化、代码块中初始化、构造器中初始化
2. final 修饰局部变量：尤其是使用final修饰形参时，表明此形参是一个常量。当我们调用此方法时，给常量形参赋一个实参。一旦赋值以后，就只能在方法体内使用此形参，但不能进行重新赋值

static final 用来修饰属性：全局常量

抽象类和抽象方法

随着继承层次中一个个新子类的定义，类变得越来越具体，而父类则更一般，更通用。类的设计应该保证父类和子类能够共享特征，有时将一个父类设计得非常抽象，以至于它没有具体得实例，这样得类叫做抽象类

abstract 关键字的使用

abstract：抽象的
abstract 可以用来修饰的结构：类，方法
开发中，都会提供抽象类的子类，让子类对象实例化，完成相关的操作

abstract 修饰类：抽象类

此类不能实例化
抽象类中一定有构造器，便于子类对象实例化的时候调用

public class AbstractTest {
    public static void main(String[] args) {
        //一旦Person类抽象了，就不可实例化
        //Person p1 = new Person();
        //p1.eat();
    }
}

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

abstract修饰方法：抽象方法

抽象方法只有方法的声明
包含抽象方法的类，一定时一个抽象类。反之，抽象类中可以没有抽象方法的。
若子类重写了父类中的所有的抽象方法后，此子类方可实例化。若若子类没有重写了父类中的所有的抽象方法，则此子类也是一个抽象类，需要用abstract修饰

abstract class Person{
    String name;
    int age;
    
    public Person(String name,int age){
        this.name = name;
        this.age = age;
    }
    // 抽象方法
    public abstract void eat();
}

abstract 使用上的注意点

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

抽象类的匿名子类

puclic class PersonTest{
    public static void main(String[] args){
        method(new Student()); //匿名对象
        
        Worker worker = new Worker();
        method1(work);//非匿名的类非匿名的对象
        
        method1(new Worker()); //非匿名的类匿名的对象
        
        //创建了一匿名子类的对象：p (Person是抽象类，造的是它的子类)
        Person p = new Person(){
            @Override
            public void eat(){
                System.out.println("吃东西");
            }
            
            @Override
            public void breath(){
                System.out.println("呼吸");
            }
        };
        
        method1(p);
        System.out.println("****************");
        //创建匿名子类的匿名对象
        method1(new Person(){
            @Override
            public void eat(){
                System.out.println("吃东西123");
            }
            
            @Override
            public void breath(){
                System.out.println("呼吸123");
            }
        });
        
        
        
    }
    public static void method1(Person p){
        p.eat();
        p.walk();

    }    
    public static void method(Person s){
        
    }
}


class Worker extents Person{
    @Override
    public void ear(){
        //TODO
    }
    
    @Override
    public void breath(){
        //TODO
    }
}

class Student extend Person{
    public Student(){
    }
    @Override
    public void eat(){
        System.out.println("学生多吃有营养的食物");
    }
    
    @Override
    public void beeath(){
        System.out.println("呼吸新鲜空气");
    }
}

abstract class Person{
    String name;
    int age;
    
    public Person(){
        
    }
    public Person(String name,int age){
        this.name = name;
        this.age = age;
    }
    
    // 抽象方法
    public abstract void eat();
    
    public void breath(){
        System.out.println("呼吸");
    }
}

抽象类的应用

设计模式 - java - dongye95 - 博客园 (cnblogs.com)

其中的模板方法设计模式

接口

概述

一方面，有时必须从几个类中派生出一个子类，继承它们所有的属性和方法。但是，java不支持多重继承。有了接口，就可以得到多重继承的效果
另一方面，有时必须从几个类中抽取出一些共同的行为特征，而它们之间又没有 is-a 的关系，仅仅时具有相同的行为特征而已。例如：鼠标、键盘、打印机、扫描仪、摄像头、充电器、MP3机、手机、数码相机、移动硬盘等都支持USB连接
接口就是规范，定义的是一组规则，体现了现实世界中“如果i你是/要...则必须能...”的思想。继承是一个“是不是”的关系，而接口实现则是“能不能”的关系
接口的本质是契约，标准，规范，就像我们的法律一样。制定好后大家都要遵守

接口的使用

使用 interface 来定义
在java中，接口和类是并列的两个结构
如何定义接口：定义接口中的成员
1. JDK7及以前：只能定义全局常量和抽象方法
  1. 全局常量：public static final的，但是书写时可以省略不写
  2. 抽象方法：public abstract的
2. JDK8：除了定义全局常量和抽象方法之外，还可以定义静态方法、默认方法
接口中不能定义构造器！意味着接口不可以实例化
java开发中，接口通过让类去实现（implements）的方式来使用。如果实现类覆盖了接口中的所有抽象方法，则此实现类就可以实例化。如果实现类没有覆盖接口中所有的抽象方法，则此实现类仍为一个抽象类
Java类可以实现多个接口，弥补了Java单继承性的局限性

格式：class AA extends BB implements CC, DD, EE
接口与接口之间可以继承，而且可以多继承

package template;

public class InterfaceTest {
    public static void main(String[] args) {
        System.out.println(Flyable.MAX_SPEED);
        System.out.println(Flyable.MIN_SPEED);

        // Flyable.MIN_SPEED = 2; 常量不能重新赋值
        Plane plane = new Plane();
        plane.fly();
    }
}

interface Flyable{
    // 全局常量
    public static final int MAX_SPEED = 7900; //第一宇宙速度
    int MIN_SPEED = 1; // 省略了 public static final

    // 抽象方法
    public abstract void fly();
    //省略了public abstract
    void stop();
}

class Plane implements Flyable{
    @Override
    public void fly(){
        System.out.println("通过引擎起飞");
    }

    @Override
    public void stop(){
        System.out.println("驾驶员减速停止");
    }
}

// 有个stop方法没实现，所以只能abstract
abstract class Kite implements Flyable{
    @Override
    public void fly(){
        System.out.println("通过引擎起飞");
    }

}

实例演示接口是一种规范

接口使用上也满足多态性
接口，实际上就是定义了一种规范
开发中，体会面向接口编程

package template;

import sun.util.locale.provider.FallbackLocaleProviderAdapter;

public class USBTest {
    public static void main(String[] args) {
        Computer com = new Computer();
        //1.创建了接口的非匿名实现类的非匿名对象
        Flash flash = new Flash();
        com.transferData(flash);

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

        //3.创建了接口的匿名实现类的非匿名对象
        USB phone = new USB() {

            @Override
            public void start() {
                System.out.println("手机开始工作");
            }

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

        //4.创建了接口的匿名实现类的匿名对象

        com.transferData(new USB() {

            @Override
            public void start() {
                System.out.println("mp3开始工作");
            }

            @Override
            public void stop() {
                System.out.println("mp3结束工作");
            }
        });

    }
}

interface USB {
    //常量：定义了长、宽、最大最小的传输速度等

    void start();

    void stop();
}

class Computer {
    public void transferData(USB usb) {
        usb.start();

        System.out.println("具体传输数据的细节");

        usb.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("打印机结束工作");
    }
}

接口的应用

代理模式
工厂模式

设计模式 - java - dongye95 - 博客园 (cnblogs.com)

java8中接口新特性

JDK8除了定义全局常量和抽象方法之外，还可以定义静态方法、默认方法

java8中，你可以为接口添加静态方法和默认方法。从技术角度来说，这是完全合法的，只是它看起来违反了接口作为一个抽象定义的理念。

静态方法：使用static关键字修饰。可以通过接口直接调用静态方法，并执行其方法体。我们经常在相互一起使用的类中使用静态方法。你可以在标准库中找到想Collection/Collections或者Path/Paths这样成对的接口和类

默认方法：默认方法使用default关键字修饰。可以通过实现类对象来调用。我们在已有的接口中提供新方法的同时，还保持了与旧版本代码的兼容性。

interface Compare8 {
    // 静态方法
    public static void method1(){
        System.out.println("Compare8:北京");
    }

    //默认方法
    public default void method2(){
        System.out.println("Compare8:上海");
    }

    default void method3(){
        System.out.println("Compare8:深圳");
    }
}

public class SubclassTest{
    public static void main(String[] args) {
        SubClass s = new SubClass();

        // 知识点1：接口中定义的静态方法，只能通过接口来调用
        //s.method1();
        //SubClass.method1();
        Compare8.method1();

        //知识点2：通过实现类的对象，可以调用接口中的默认方法
        //如果实现类中重写了接口中的默认方法，调用时，仍然调用的是重写的方法

        s.method2();
        s.method3();

    }
}

class SubClass implements Compare8 {
    public void method2(){
        System.out.println("Compare8:上海");
    }
}

如果有父类

package template;

import sun.plugin2.gluegen.runtime.CPU;

import java.awt.*;

interface Compare8 {
    // 静态方法
    public static void method1(){
        System.out.println("Compare8:北京");
    }

    //默认方法
    public default void method2(){
        System.out.println("Compare8:上海");
    }

    default void method3(){
        System.out.println("Compare8:深圳");
    }
}

public class SubclassTest{
    public static void main(String[] args) {
        SubClass s = new SubClass();

        // 知识点1：接口中定义的静态方法，只能通过接口来调用
        //s.method1();
        //SubClass.method1();
        Compare8.method1();

        //知识点2：通过实现类的对象，可以调用接口中的默认方法
        //如果实现类中重写了接口中的默认方法，调用时，仍然调用的是重写的方法
        s.method2();

        //知识点3：如果子类（实现类）继承的父类和实现的接口中声明了同名同参数的方法，
        //那么子类在没有重写此方法的情况下，默认调用的是父类中的同名同参数的方法 ---> 类优先原则
        s.method3();

    }
}

class SubClass extends SuperClass implements Compare8 {
    public void method2(){
        System.out.println("Compare8:上海");
    }
}

class SuperClass {
    public void method3(){
        System.out.println("SuperClass:上海");
    }
}

如果没有继承

package template;

import sun.plugin2.gluegen.runtime.CPU;

import java.awt.*;

interface Compare8 {
    // 静态方法
    public static void method1(){
        System.out.println("Compare8:北京");
    }

    //默认方法
    public default void method2(){
        System.out.println("Compare8:上海");
    }

    default void method3(){
        System.out.println("Compare8:深圳");
    }
}

interface Compare8B {
    default void method3(){
        System.out.println("Compare8B:深圳");
    }
}

public class SubclassTest{
    public static void main(String[] args) {
        SubClass s = new SubClass();

        //知识点4：如果实现类实现了多个接口，而这多个接口定义了同名同参数的默认方法，
        //那么在实现类没有重写此方法的情况下，报错。--->接口冲突
        //这就需要我们必须在实现类中重写此方法
        s.method3();

    }
}

class SubClass implements Compare8, Compare8B {
    public void method2(){
        System.out.println("Compare8:上海");
    }
    //没有重写method3会直接报错
    public void method3(){
        System.out.println("重写");
    }
}

class SuperClass {
    public void method3(){
        System.out.println("SuperClass:上海");
    }
}

内部类

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

内部类的分类：成员内部类（静态、非静态） VS 局部内部类（方法内、代码块内、构造器内）

package innerclass;

public class InnerClassTest {
}

class Person{

    //静态成员内部类
    static class DD{

    }

    //非静态成员内部类
    class EE{

    }
    public void mehtod(){
        //局部内部类
        class AA{

        }
    }
    //局部内部类
    {
        class BB{

        }
    }

    public Person(){
        //局部内部类
        class CC{

        }
    }
}

成员内部类

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

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

另一方面，作为一个类：

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

package innerclass;

public class InnerClassTest {
}

class Person{

    String name;
    int age;
    public void eat(){
        System.out.println("人，吃饭");
    }



    //静态成员内部类
    static class Dog{
        String name;
        int age;

        public void show(){
            System.out.println("卡拉是条狗");
            //eat(); 静态不能调用非静态
        }
    }

    //非静态成员内部类
    class Bird{
        String name;
        public Bird(){

        }
        public void sing(){
            System.out.println("我是一只小小鸟");
            Person.this.eat(); //调用外部类的非静态属性。可以省略简写为 eat();
        }
    }
    public void mehtod(){
        //局部内部类
        class AA{

        }
    }
    //局部内部类
    {
        class BB{

        }
    }

    public Person(){
        //局部内部类
        class CC{

        }
    }
}

如何实例化成员内部类

package innerclass;

public class InnerClassTest {
    public static void main(String[] args) {

        //创建Dog实例（静态的成员内部类）
        Person.Dog dog = new Person.Dog();
        dog.show();

        //创建Bird 实例（非静态的成员内部类）：
//        Person.Bird bird = new Person.Bird(); //错误的
        Person p = new Person();
        Person.Bird bird = p.new Bird();
        bird.sing();
    }
}

class Person{

    String name;
    int age;
    public void eat(){
        System.out.println("人，吃饭");
    }



    //静态成员内部类
    static class Dog{
        String name;
        int age;

        public void show(){
            System.out.println("卡拉是条狗");
            //eat(); 静态不能调用非静态
        }
    }

    //非静态成员内部类
    class Bird{
        String name;
        public Bird(){

        }
        public void sing(){
            System.out.println("我是一只小小鸟");
            Person.this.eat(); //调用外部类的非静态属性。可以省略简写为 eat();
        }
    }
    public void mehtod(){
        //局部内部类
        class AA{

        }
    }
    //局部内部类
    {
        class BB{

        }
    }

    public Person(){
        //局部内部类
        class CC{

        }
    }
}

成员内部类中调用外部类的结构

方式一：

package innerclass;

public class InnerClassTest {
    //开发中很少见
    public void method(){
        //局部内部类
        class AA{

        }

        //返回一个实现了Comparable接口的类的对象
        public Comparable getComparable(){
            //创建一个实现了Comparable接口的类：局部内部类
            class MyComparable implements Comparable{

                @Override
                public int compareTo(Object o) {
                    return 0;
                }
            }
            return new MyComparable();

        }
    }
}

方式二：

package innerclass;

public class InnerClassTest {
    //开发中很少见
    public void method() {
        //局部内部类
        class AA {

        }

        //返回一个实现了Comparable接口的类的对象
        public Comparable getComparable() {

            return new Comparable(){

                @Override
                public int compareTo(Object o) {
                    return 0;
                }
            }
        }
    }
}

posted @ 2021-10-23 20:31 dongye95 阅读(40) 评论(0) 编辑收藏举报

会员力量，点亮园子希望

刷新页面返回顶部

dongye95