Java基础知识总结（第五篇）：面向对象编程进阶(静态变量/方法代码块，抽象类、接口和内部类)

已于 2024-04-11 18:31:25 修改
阅读量1.6k 收藏 31
点赞数 35
分类专栏： java基础知识 文章标签： java 开发语言
于 2024-01-31 09:30:00 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/2301_76144723/article/details/135838104
版权

声明: 
              1. 本文根据韩顺平老师教学视频自行整理，以便记忆
              2. 若有错误不当之处, 请指出

系列文章目录

Java基础知识总结（第一篇）：基础语法

Java基础知识总结（第二篇）：流程控制语句(分支控制和循环控制)

Java基础知识总结（第三篇）：数组、排序和查找

Java基础知识总结（第四篇）：面向对象编程基础(类、对象、方法、包以及封装继承多态)

Java基础知识总结（第六篇）：枚举、注解和异常

Java基础知识总结（第七篇）：常用类：包装类、日期类以及String、StringBuffer、Builder、Math 、Arrays 、System 、BigInteger和BigDecimal

Java基础知识总结（第八篇）：集合：Collection(List、Set)、Map、Collections 工具类

Java基础知识总结（第九篇）：泛型

目录

一、类变量和类方法

1.类变量

2.类方法

二、main方法理解和单例设计模式

1.main方法

2.单例设计模式

三、代码块和FINAL关键字

1.代码块

2.final关键字

四、抽象类

五、接口

六、内部类

内部类分类

1.定义在外部类局部位置上(比如方法内)

（1）局部内部类(有类名)

（2）匿名内部类(没有类名)

2.定义在外部类的成员位置上

（1）成员内部类(没用static修饰)

（2）静态内部类(使用static修饰)

一、类变量和类方法

1.类变量

类变量也叫静态变量/静态属性，是该类的所有对象共享的变量，任何一个该类的对象去访问它时，取到的都是相同的值，同样任何一个该类的对象去修改它时，修改的也是同一个变量。

定义语法：

（1）访问修饰符 static 数据类型 变量名；(推荐)

（2）static 访问修饰符 数据类型 变量名；

访问类变量：类名.类变量名(推荐) 或者 对象名.类变量名

实例代码：

public class VisitStatic {
    public static void main(String[] args) {
    //类名.类变量名
    //说明：类变量是随着类的加载而创建，所以即使没有创建对象实例也可以访问
        System.out.println(A.name);
        A a = new A();
    //通过对象名.类变量名
        System.out.println("a.name=" + a.name);
    }
}
class A {
    //类变量
    public static String name = "教育";
    //普通属性
    private int num = 10;
}

运行结果：

类变量使用细节：

  • 当需要让某个类的所有对象都共享一个变量时，就可以考虑使用类变量(静态变量)
  • 类变量是该类的所有对象共享的，而实例变量是每个对象独享的。
  • 加上static称为类变量或静态变量，否则称为实例变量/普通变量/非静态变量
  • 类变量是在类加载时就初始化了，也就是说，即使你没有创建对象，只要类加载了，就可以使用类变量了。
  • 类变量的生命周期是随类的加载开始，随着类消亡而销毁。

2.类方法

类方法也叫静态方法。

定义语法：

（1）访问修饰符 static 数据返回类型 方法名(){}（推荐）

（2）static 访问修饰符 数据返回类型 方法名(){}

调用类方法：类名.类方法名 或者 对象名.类方法名

实例代码：

public class StaticMethod {
    public static void main(String[] args) {
//创建 2 个学生对象，叫学费
        Stu tom = new Stu("tom");
//tom.payFee(100);
        Stu.payFee(100);//对不对?对
        Stu mary = new Stu("mary");
//mary.payFee(200);
        Stu.payFee(200);//对
//输出当前收到的总学费
        Stu.showFee();//300
//如果我们希望不创建实例，也可以调用某个方法(即当做工具来使用)
//这时，把方法做成静态方法时非常合适
        System.out.println("9 开平方的结果是=" + Math.sqrt(9));
        System.out.println(MyTools.calSum(10, 30));
    }
}
//开发自己的工具类时，可以将方法做成静态的，方便调用
class MyTools {
    //求出两个数的和
    public static double calSum(double n1, double n2) {
        return n1 + n2;
    }
}
class Stu {
    private String name;//普通成员
    //定义一个静态变量，来累积学生的学费
    private static double fee = 0;

    public Stu(String name) {
        this.name = name;
    }

    //1. 当方法使用了 static 修饰后，该方法就是静态方法
    //2. 静态方法就可以访问静态属性/变量
    public static void payFee(double fee) {
        Stu.fee += fee;//累积到
    }

    public static void showFee() {
        System.out.println("总学费有:" + Stu.fee);
    }
}

运行结果：

类方法使用细节：

  • 类方法(静态方法)，只能访问静态的成员，非静态的方法，可以访问静态成员和非静态成员

二、main方法理解和单例设计模式

1.main方法

解释main方法的形式：public static void main(String[] args)

（1）main方法是虚拟机调用

（2）java虚拟机需要调用类的main()方法，所以该方法的访问权限必须是public

（3）java虚拟机在执行mainO方法时不必创建对象，所以该方法必须是static

（4）该方法接收String类型的数组参数，该数组中保存执行java命令时传递给所运行的类的参数

说明：

（1）在 main()方法中，可以直接调用 main 方法所在类的静态方法或静态属性。

（2）但是，不能直接访问该类中的非静态成员，必须创建该类的一个实例对象后，才能通过这个对象去访问类中的非静态成员。

2.单例设计模式

所谓类的单例设计模式，就是采取一定的方法保证在整个的软件系统中，对某个类只能存在一个对象实例，并且该类只提供一个取得其对象实例的方法。单例模式有两种方式：1)饿汉式2)懒汉式

（1）饿汉式步骤如下：

1)构造器私有化，防止直接new

2)类的内部创建一个static 静态属性对象

3)向外暴露一个静态的公共方法。getlnstance

class GirlFriend {
    //餓漢式可能造成創建了對象，但是沒有使用.
    private String name;
    //为了能够在静态方法中，返回 gf 对象，需要将其修饰为 static
    private static GirlFriend gf = new GirlFriend("小红红");
    private GirlFriend(String name) {
        System.out.println("構造器被調用.");
        this.name = name;
    }

    public static GirlFriend getInstance() {
        return gf;
    }
}

（2）懒汉式步骤如下：

懒汉式，只有当用户使用 getInstance时 ，才返回 cat 对象 , 后面再次调用时，会返回上次创建的 cat 对象
1)仍然构造器私有化
2)定义一个 static 静态属性对象

3)提供一个 public 的 static 方法，可以返回一个 Cat 对象

class Cat {
    private String name;
    public static int n1 = 999;
    //定义一个 static 静态属性对象
    private static Cat cat; //默认是 null
    
    //构造器私有化
    private Cat(String name) {
        System.out.println("构造器调用...");
        this.name = name;
    }

    // 提供一个 public 的 static 方法，可以返回一个 Cat 对象
    public static Cat getInstance() {
        if (cat == null) {//如果还沒有创建 cat 對象
            cat = new Cat("小可愛");
        }
        return cat;
    }
}

（3）饿汉式和懒汉式区别

  • 二者最主要的区别在于创建对象的时机不同：饿汉式是在类加载就创建了对象实例，而懒汉式是在使用时才创建。
  • 饿汉式不存在线程安全问题，懒汉式存在线程安全问题。
  • 饿汉式存在浪费资源的可能。因为如果程序员一个对象实例都没有使用，那么饿汉式创建的对象就浪费了，懒汉式是使用时才创建，就不存在这个问题。

三、代码块和FINAL关键字

1.代码块

代码化块又称为初始化块，属于类中的成员(是类的一部分),类似于方法，将逻辑语句封装在方法体中，通过{}包围起来。但和方法不同，没有方法名，没有返回，没有参数，只有方法体，而且不用通过对象或类显式调用，而是加载类时，或创建对象时隐式调用。

语法：

[修饰符]{

代码

};

说明：

  • 修饰符可选，要写的话，也只能写static
  • 代码块分为两类，使用static修饰的叫静态代码块，没有static修饰的，叫普通代码块/非静态代码块。
  • 逻辑语句可以为任何逻辑语句(输入、输出、方法调用、循环、判断等)
  • ;号可以写上，也可以省略。

使用细节：

（1）static代码块是类第一次加载时，执行，只会执行一次

（2）普通代码块是在创建对象时调用的，创建一次，调用一次

（3）类加载的3种情况

  • 创建对象实例时(new)
  • 创建子类对象实例，父类也会被加载。父类先被加载，子类后被加载。
  • 使用类的静态成员时(静态属性，静态方法)
//1. 创建对象实例时(new)
// AA aa = new AA();
//2. 创建子类对象实例，父类也会被加载, 而且，父类先被加载，子类后被加载
// AA aa2 = new AA();
//3. 使用类的静态成员时(静态属性，静态方法)
// System.out.println(Cat.n1);

（4）创建一个对象时，在一个类调用顺序是：

①调用静态代码块和静态属性初始化(静态代码块和静态属性初始化调用的优先级一样，如果有多个静态代码块和多个静态变量初始化，则按他们定义的顺序调用)

②调用普通代码块和普通属性的初始化(如果有多个普通代码块和多个普通属性初始化，则按定义顺序调用)

③调用构造方法。

（5）创建一个子类对象时(继承关系),调用顺序如下：

①父类的静态代码块和静态属性(优先级一样，按定义顺序执行)

②子类的静态代码块和静态属性(优先级一样，按定义顺序执行)

③父类的普通代码块和普通属性初始化(优先级一样，按定义顺序执行)

④父类的构造方法

⑤子类的普通代码块和普通属性初始化(优先级一样，按定义顺序执行)

⑥子类的构造方法

2.final关键字

final可以修饰类、属性、方法和局部变量.

以下需求，就会使用到final:

  • 当不希望类被继承时，可以用final修饰。final class A { }
  • 当不希望父类的某个方法被子类覆盖/重写(override)时，可以用final关键字修饰。public final void hi() {}
  • 当不希望类的的某个属性的值被修改，可以用final修饰，即常量。public final double TAX_RATE = 0.08;//常量
  • 当不希望某个局部变量被修改，可以使用final修饰，即局部常量。final double NUM = 0.01;

使用细节：

  • final修饰的属性又叫常量，一般用XX_XX_XX来命名
  • final修饰的属性在定义时，必须赋初值，并且以后不能再修改，赋值可以在如下位置之一:①定义时：如public final double TAX RATE=0.08;②在构造器中③在代码块中。
  • 如果final修饰的属性是静态的，则初始化的位置只能是①定义时②在静态代码块不能在构造器中赋值。
  • final类不能继承，但是可以实例化对象。
  • 如果类不是final类，但是含有final方法，则该方法虽然不能重写，但是可以被继承。

  • 一般来说，如果一个类已经是final类了，就没有必要再将方法修饰成final方法。

  • final不能修饰构造方法(即构造器)。

  • 包装类(Integer,Double,Float,Boolean等都是final),String也是final类。

public class FinalDetail01 {
    public static void main(String[] args) {
        CC cc = new CC();
        new EE().cal();
    }
}
class AA {
    /*
    1. 定义时：如 public final double TAX_RATE=0.08;
    2. 在构造器中
    3. 在代码块中
    */
    public final double TAX_RATE = 0.08;//1.定义时赋值
    public final double TAX_RATE2 ;
    public final double TAX_RATE3 ;
    public AA() {//构造器中赋值
        TAX_RATE2 = 1.1;
    }
    {//在代码块赋值
        TAX_RATE3 = 8.8;
    }
}
class BB {
    /*
    如果 final 修饰的属性是静态的，则初始化的位置只能是
    1 定义时 2 在静态代码块 不能在构造器中赋值。
    */
    public static final double TAX_RATE = 99.9;
    public static final double TAX_RATE2 ;
    static {
        TAX_RATE2 = 3.3;
    }
}

//final 类不能继承，但是可以实例化对象
final class CC { }

//如果类不是 final 类，但是含有 final 方法，则该方法虽然不能重写，但是可以被继承 
class DD {
    public final void cal() {
        System.out.println("cal()方法");
    }
}
class EE extends DD { }

四、抽象类

当父类的某些方法，需要声明，但是又不确定如何实现时，可以将其声明为抽象方法，那么这个类就是抽象类

abstract class Animal {
    private String name;
    public Animal(String name) {
        this.name = name;
    }
    // 当一个类中存在抽象方法时，需要将该类声明为 abstract 类
    public abstract void eat() ;
}

语法

抽象类：访问修饰符 abstract class 类名 {}

抽象方法：访问修饰符 abstract 返回类型 方法名(参数列表);//没有方法体

使用细节

  • 抽象类不能被实例化。
  • 抽象类不一定要包含abstract方法。也就是说，抽象类可以没有abstract方法。
  • 一旦类包含了abstract方法，则这个类必须声明为abstract。
  • abstract只能修饰类和方法，不能修饰属性和其它的。
  • 抽象类可以有任意成员(抽象类本质还是类)。
  • 抽象方法不能有主体，即不能实现。
  • 如果一个类继承了抽象类，则它必须实现抽象类的所有抽象方法，除非它自己也声明为abstract类。
  • 抽象方法不能使用private、final和static来修饰，因为这些关键字都是和重写相违背的。

五、接口

接口就是给出一些没有实现的方法，封装到一起，到某个类要使用的时候，在根据具体情况把这些方法写出来。接口是更加抽象的抽象的类，抽象类里的方法可以有方法体，接口里的所有方法都没有方法体(jdk7.0)。Jdk8.0后接口类可以有静态方法，默认方法，也就是说接口中可以有方法的具体实现

语法：

interface 接口名{

        //属性

        //抽象方法

}

class 类名 implements 接口{

        自己属性；

        自己方法；

        必须实现的接口的抽象方法;

}

使用细节：

（1）接口不能被实例化

（2）接口中所有的方法都是public方法，接口中抽象方法，public和abstract可以省略

（3）一个普通类实现接口，就必须将该接口的所有方法都实现。

（4）抽象类实现接口，可以不用实现接口的方法

public class InterfaceDetail01 {
    public static void main(String[] args) {
        //1.接口不能被实例化
        //new IA();
    }
}
interface IA {
    void say();//省略public和abstract
    void hi();
}
class Cat implements IA{
//    一个普通类实现接口,就必须将该接口的所有方法都实现,可以使用 alt+enter 来解决
    @Override
    public void say() {
    }
    @Override
    public void hi() {
    }
}
abstract class Tiger implements IA {
//    抽象类去实现接口时，可以不实现接口的抽象方法
}

（5）一个类同时可以实现多个接口

（6）接口中的属性，只能是final的，而且是public static final修饰符。比如：int a=1;实际上是public static final int a=1;(必须初始化)

（7）接口中属性的访问形式：接口名.属性名

（8）接口不能继承其它的类，但是可以继承多个别的接口。interface A extends B,C{}

（9）接口的修饰符只能是public和默认，这点和类的修饰符是一样的。

public class InterfaceDetail02 {
    public static void main(String[] args) {
        System.out.println(IB.n1);//说明 n1 就是 static
//IB.n1 = 30; 说明 n1 是 final
    }
}
interface IB {
    int n1 = 10; //等价 public static final int n1 = 10;
    void hi();
}
interface IC {
    void say();
}
//接口不能继承其它的类,但是可以继承多个别的接口
interface ID extends IB,IC {
}
//接口的修饰符 只能是 public 和默认，这点和类的修饰符是一样的
interface IE{}
//一个类同时可以实现多个接口
class Pig implements IB,IC {
    @Override
    public void hi() {
    }
    @Override
    public void say() {
    }
}

六、内部类

一个类的内部又完整的嵌套了另一个类结构。被嵌套的类称为内部类(inner class),嵌套其他类的类称为外部类(outer class)。是我们类的第五大成员(属性、方法、构造器、代码块、内部类),内部类最大的特点就是可以直接访问私有属性，并且可以体现类与类之间的包含关系。

基本语法：

Class Outer{ //外部类

        class Inner{//内部类

        }

}

内部类分类

1.定义在外部类局部位置上(比如方法内)

（1）局部内部类(有类名)

使用说明：

  • 可以直接访问外部类的所有成员，包含私有的
  • 不能添加访问修饰符，因为它的地位就是一个局部变量。局部变量是不能使用修饰符的。可以使用final修饰，因为局部变量也可以使用final
  • 作用域：仅仅在定义它的方法或代码块中。
  • 如果外部类和局部内部类的成员重名时，默认遵循就近原则，如果想访问外部类的成员，则可以使用(外部类名.this.成员)去访问

实例代码：

public class LocalInnerClass {//
    public static void main(String[] args) {
//演示一遍
        Outer02 outer02 = new Outer02();
        outer02.m1();
        System.out.println("outer02 的 hashcode=" + outer02);
    }
}
class Outer02 {//外部类
    private int n1 = 100;
    private void m2() {
        System.out.println("Outer02 m2()");
    }//私有方法
    public void m1() {//方法
        // 定义在方法中，不能添加访问修饰符,但是可以使用 final 修饰
        final class Inner02 {//局部内部类(本质仍然是一个类)
            private int n1 = 800;
            public void f1() {
//如果外部类和局部内部类的成员重名时，默认遵循就近原则，如果想访问外部类的成员，
// 使用 外部类名.this.成员）去访问
// Outer02.this 本质就是外部类的对象, 即哪个对象调用了 m1, Outer02.this 就是哪个对象
                System.out.println("内部类的 n1=" + n1 + " 外部类的 n1=" + Outer02.this.n1);
                System.out.println("Outer02.this hashcode=" + Outer02.this);
                //局部内部类可以直接访问外部类的成员
                m2();
            }
        }
//外部类在方法中，可以创建 Inner02 对象，然后调用方法即可
        Inner02 inner02 = new Inner02();
        inner02.f1();
    }
}

运行结果：

（2）匿名内部类(没有类名)

语法：

new类或接口(参数列表){

        类体

}

基于接口匿名内部类

IA tiger = new IA() {//IA是一个接口
    @Override
    public void cry() {
        System.out.println("老虎叫唤...");
    }
};
tiger.cry();

基于类的匿名内部类

Father father = new Father("jack"){
    @Override
    public void test() {
        System.out.println("匿名内部类重写了 test 方法");
    }
};
father.test();

基于抽象类的匿名内部类

Animal animal = new Animal(){
    @Override
    void eat() {
        System.out.println("小狗吃骨头...");
    }
};
animal.eat();

说明：

  • 匿名内部类的语法比较奇特，请大家注意，因为匿名内部类既是一个类的定义，同时它本身也是一个对象，因此从语法上看，它既有定义类的特征，也有创建对象的特征
  • 可以直接访问外部类的所有成员，包含私有的
  • 不能添加访问修饰符，因为它的地位就是一个局部变量。
  • 作用域：仅仅在定义它的方法或代码块中。
  • 如果外部类和匿名内部类的成员重名时，匿名内部类访问的话，默认遵循就近原则，如果想访问外部类的成员，则可以使用(外部类名.this.成员)去访问

2.定义在外部类的成员位置上

（1）成员内部类(没用static修饰)

成员内部类是定义在外部类的成员位置，并且没有static修饰。

说明：

  • 可以直接访问外部类的所有成员，包含私有的
  • 可以添加任意访问修饰符(public、protected、默认、private),因为它的地位就是一个成员。
  • 作用域和外部类的其他成员一样，为整个类体比如前面案例，在外部类的成员方法中创建成员内部类对象，再调用方法.
  • 如果外部类和内部类的成员重名时，内部类访问的话，默认遵循就近原则，如果想访问外部类的成员，则可以使用(外部类名.this.成员)去访问

实例代码：

public class MemberInnerClass01 {
    public static void main(String[] args) {
        Outer08 outer08 = new Outer08();
        outer08.t1();
        //外部其他类，使用成员内部类的两种方式
        // 第一种方式
        Outer08.Inner08 inner08 = outer08.new Inner08();//相当于把 new Inner08()当做是 outer08 成员
        inner08.say();
        // 第二种方式 在外部类中，编写一个方法，可以返回 Inner08 对象
        Outer08.Inner08 inner08Instance = outer08.getInner08Instance();
        inner08Instance.say();
    }
}
class Outer08 { //外部类
    private int n1 = 10;
    public String name = "张三";
    private void hi() {
        System.out.println("hi()方法...");
    }
    //1.注意: 成员内部类，是定义在外部内的成员位置上
//2.可以添加任意访问修饰符(public、protected 、默认、private),因为它的地位就是一个成员
    public class Inner08 {//成员内部类
        private double sal = 99.8;
        private int n1 = 66;
        public void say() {
//可以直接访问外部类的所有成员，包含私有的
//如果成员内部类的成员和外部类的成员重名，会遵守就近原则.可以通过 外部类名.this.属性 来访问外部类的成员
            System.out.println("n1 = " + n1 + " name = " + name + " 外部类的 n1=" + Outer08.this.n1);
            hi();
        }
    }
    //方法，返回一个 Inner08 实例
    public Inner08 getInner08Instance(){
        return new Inner08();
    }
    //写方法
    public void t1() {
//使用成员内部类
//创建成员内部类的对象，然后使用相关的方法
        Inner08 inner08 = new Inner08();
        inner08.say();
        System.out.println(inner08.sal);
    }
}

运行结果：

（2）静态内部类(使用static修饰)

静态内部类是定义在外部类的成员位置，并且有static修饰

说明：

  • 可以直接访问外部类的所有静态成员，包含私有的，但不能直接访问非静态成员
  • 可以添加任意访问修饰符(public、protected、默认、private),因为它的地位就是一个成员。
  • 作用域：同其他的成员，为整个类体
  • 如果外部类和静态内部类的成员重名时，静态内部类访问的时，默认遵循就近原则，如果想访问外部类的成员，则可以使用(外部类名.成员)去访问

代码实例：

public class StaticInnerClass01 {
    public static void main(String[] args) {
        Outer10 outer10 = new Outer10();
        outer10.m1();
//外部其他类 使用静态内部类
//方式 1
//因为静态内部类，是可以通过类名直接访问(前提是满足访问权限)
        Outer10.Inner10 inner10 = new Outer10.Inner10();
        inner10.say();
//方式 2
//编写一个方法，可以返回静态内部类的对象实例.
        Outer10.Inner10 inner101 = outer10.getInner10();
        System.out.println("============");
        inner101.say();
        Outer10.Inner10 inner10_ = Outer10.getInner10_();
        System.out.println("************");
        inner10_.say();
    }
}
class Outer10 { //外部类
    private int n1 = 10;
    private static String name = "张三";
    private static void cry() {}
//Inner10 就是静态内部类
//1. 放在外部类的成员位置
//2. 使用 static 修饰
//3. 可以直接访问外部类的所有静态成员，包含私有的，但不能直接访问非静态成员
//4. 可以添加任意访问修饰符(public、protected 、默认、private),因为它的地位就是一个成员
//5. 作用域 ：同其他的成员，为整个类体
    static class Inner10 {
        private static String name = "教育";
        public void say() {
//如果外部类和静态内部类的成员重名时，静态内部类访问的时，
//默认遵循就近原则，如果想访问外部类的成员，则可以使用 （外部类名.成员）
            System.out.println(name + " 外部类 name= " + Outer10.name);
            cry();
        }
    }
    public void m1() { //外部类访问静态内部类 访问方式：创建对象，再访问
        Inner10 inner10 = new Inner10();
        inner10.say();
    }
    public Inner10 getInner10() {
        return new Inner10();
    }
    public static Inner10 getInner10_() {
        return new Inner10();
    }
}

运行结果：

随遇而安622&508
关注
  • 35
    点赞
  • 踩
  • 31
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值