第十章：面向对象编程（高级部分）（上）

最新推荐文章于 2024-07-29 14:22:26 发布
最新推荐文章于 2024-07-29 14:22:26 发布
阅读量358 收藏
点赞数 1
文章标签： java 开发语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_64513441/article/details/125420223
版权

                                                目录

10.1类变量（静态变量）类方法

10.2类变量的内存布局

10.3如何访问类变量

10.4类变量使用注意事项和细节讨论

10.5 类方法（static静态方法）   

10.6类方法的使用场景

10.7 类方法使用细节

10.8深入理解mian方法（public static void main(String [] args）{}

10.9 代码块

10.10代码块注意事项

10.11代码块的用处及案例演示

3、案例演示

10.12代码块的注意事项和使用细节

2.类什么时候被加载呢?(重点)

10.13创建对象时，在一个类中的调用顺序（重点）

10.14 创建一个子类对象时，他们的静态代码块，静态属性初始化，普通代码块，普通属性初始化，构造方法的调用顺序如下

10.1类变量（静态变量）类方法

  1. 静态变量最大的特点就是会被其所在类中的所有对象实例共享（private static int n1 = 10;）
  2. 访问类变量：类名.类变量名
  3. 类变量是随着类的加载而创建，所以即使没有创建对象实例也可以访问
  4. 类变量的访问也必须遵守访问权限

10.2类变量的内存布局

这里需要注意的是static变量的位置跟jdk的版本有关，有的说是在方法区有的说是在静态域。

不管她在哪我们需要记住以下两点

1、static变量是同一个类所有对象共享

2、static类变量在类加载的时候就生成了

10.3如何访问类变量

1、访问类变量：类名.类变量名 or 对象名.类变量名

2、注意：静态变量的访问修饰符和访问范围权限和普通变量是一样的

10.4类变量使用注意事项和细节讨论

  1. 什么时候需要使用类变量

当我们需要让某个类的所有对象共用一个变量时，可以将该变量设置成静态变量

2、加上static 称为类变量或者静态变量否则称为 普通变量/实例变量/非静态变量

3、访问类变量：类名.类变量名 or 对象名.类变量名（java设计者推荐我们使用类名.类变量名）

4、类变量在类加载时就初始化了，就是说即使没有创建对象，只要类加载了就可以使用类变量

10.5 类方法（static静态方法）   

  1. public static void infor(){} //访问修饰符 static 数据返回类型 方法名（）{}

  2. 同样得满足访问权限
  3. 开发自己的工具类时，可以将方法做成静态的，方便调用

10.6类方法的使用场景

1、当方法中不涉及任何和对象相关的成员，则可以将方法设计成静态方法，提高开发效率

10.7 类方法使用细节

  1. 类方法和普通方法都是随着类的加载而加载，将结构信息储存在方法区，类方法中无this、super的参数，不能使用this，super。 普通方法中隐含着this参数，this和super都可以使用
  2. 类方法可以通过类名调用，同样也可以通过对象名调用

  3. 类方法（静态方法）只能调用静态成员（静态属性、静态方法）

  4. 普通方法既可以调用静态成员（静态属性、静态方法）也可以调用普通成员（普通属性、普通方法）

10.8深入理解mian方法（public static void main(String [] args）{}

  1. main方法是谁调用的呢？答：虚拟机调用
  2. java虚拟机要调用类的main()方法，所以该方法的访问权限必须时public
  3. java虚拟机在执行main()方法不必时不必创建对象，所以该方法必须是static
  4. 该方法接收的时String类型的数组参数，该数组中保存执行java命令时传递给所运行的类的参数
  5. 提示：在main‘方法中我们可以直接调用main方法所在类的静态属性
  6. 但是不能直接调用非静态属性，必需实例化对象后才能通过对象调用

10.9 代码块

1.基本介绍：代码块属于类中的成员（是类的一部分）类似于方法，将逻辑语言封装到方法体中，通过{}包围起来。

2、和方法不同，没有方法名，没有返回，没有参数，只有方法体，并且不用通过对象调用，而是在类加载的时候或者创建对象时隐式调用。

3、语法 修饰符{

        代码

}

10.10代码块注意事项

1、修饰符要是写的话只能写static

2、代码块分为两类，使用static修饰的代码块，叫做静态代码块，否则称为普通代码块

3、代码块中的逻辑语句可以为任意的逻辑语句

5、;可以写，也可以省略

10.11代码块的用处及案例演示

1、我的理解：代码块相当于另一种形式的构造器（对构造器的补充机制），可以做初始化的操作

2、使用场景：如果多个构造器中都含有重复的语句，可以抽取到初始代码块中，提高代码的重用性

3、案例演示

package com.cds.block;

public class Test01 {
    public static void main(String[] args) {
        Movie movie = new Movie("泰坦尼克号");
        System.out.println("================================");
        Movie movie1 = new Movie("泰坦尼克号",39);
        System.out.println("================================");
        Movie movie2 = new Movie("泰坦尼克号",39,"jack");
    }
}
class Movie{
    private String name;
    private double price;
    private String director;

     {
        System.out.println("电影屏幕打开...");
        System.out.println("广告开始...");
        System.out.println("电影正是开始...");
    }


    /*
    * (1) 下面的三个构造器都有相同的语句
    * (2)这样代码看起来比较冗余
    * (3) 这时我们可以把相同的语句，放入到一个代码块中，即可
    *(4) 这样当我们不管调用哪个构造器，创建对象，都会先调用代码块的内容
    * （5）代码块调用的顺序优先于构造器.
     */


    public Movie(String name) {
//        System.out.println("电影屏幕打开...");
//        System.out.println("广告开始...");
//        System.out.println("电影正是开始...");
        this.name = name;
    }

    public Movie(String name, double price) {
//        System.out.println("电影屏幕打开...");
//        System.out.println("广告开始...");
//        System.out.println("电影正是开始...");
        this.name = name;
        this.price = price;
    }

    public Movie(String name, double price, String director) {
//        System.out.println("电影屏幕打开...");
//        System.out.println("广告开始...");
//        System.out.println("电影正是开始...");
        this.name = name;
        this.price = price;
        this.director = director;
    }
}

10.12代码块的注意事项和使用细节

1、static代码块也叫静态代码块，静态代码块时随着类的加载被执行，且只会执行一次，而普通代码块 每创建一个对象就被调用

2.类什么时候被加载呢?(重点)

  1. 创建对象实例时（new）
  2. 创建子类对象实例时，父类也会被加载
  3. 使用类的静态成员时（静态属性，静态方法）

案例演示

//创建对象实例时（new）,静态代码块和普通代码块都执行，且静态优先，因为先加载类

//使用类的静态成员时（静态属性，静态方法）,类加载，静态代码块执行

//当创建子类对象时，先调用父类的静态代码块，再子类静态代码块，再父类普通代码块，再子类普通代码块。

 源码：

package com.cds.block;
/*
* 1、static代码块也叫静态代码块，静态代码块时随着类的加载被执行，
* 且只会执行一次，而普通代码块 每创建一个对象就被调用
2.类什么时候被加载呢?(重点)
创建对象实例时（new）
创建子类对象实例时，父类也会被加载
使用类的静态成员时（静态属性，静态方法）*/
public class Test02 {
    public static void main(String[] args) {
//        System.out.println(A.age);//使用类的静态成员时（静态属性，静态方法）,类加载
//        A a = new A();//创建对象实例时（new）,静态代码块和普通代码块都执行，且静态优先，因为先加载类
        B b = new B();
    }
}
class A{
    public static int age = 100;
    public static void say(){
        System.out.println("A类中say()静态方法执行");
    }
    static {
        System.out.println("A类的静态代码块执行");
    }
    {
        System.out.println("A类的普通代码块被执行");
    }

}
class  B extends A{
    static {
        System.out.println("B类的静态代码块执行");
    }
    {
        System.out.println("B类的普通代码块被执行");
    }
}

10.13创建对象时，在一个类中的调用顺序（重点）

(1)调用静态代码块和静态属性初始化（注意静态代码块和静态属性的优先级是一样的如果有多个静态代码块和静态属性则按照他们的顺序执行）

（2）调用普通代码块和普通属性（注意普通代码块和普通属性的优先级是一样的如果有多个普通代码块和普通属性则按照他们的顺序执行）

案例演示

 源码：

package com.cds.block;


/*
* (1)调用静态代码块和静态属性初始化
* （注意静态代码块和静态属性的优先级是一样的
* 如果有多个静态代码块和静态属性则按照他们的顺序执行）

（2）调用普通代码块和普通属性
* （注意普通代码块和普通属性的优先级是一样的
* 如果有多个普通代码块和普通属性则按照他们的顺序执行）*/
public class Test03 {
    public static void main(String[] args) {
        AA aa = new AA(19);
    }
}
class AA{
    private static int age = getAge();
    static {
        System.out.println("AA类中静态代码块被执行");
    }

    public  static int getAge(){
        System.out.println("AA类中getAge()被调用,静态变量初始化");
        return 100;
    }

    public AA(int age) {
        System.out.println("AA类中构造器被调用");
        this.age = 10;
    }

    public static void say(){
        System.out.println("AA类中静态方法say()被执行");
    }

    public void hello(){
        System.out.println("AA类中普通方法hello()被执行");
    }
    private int n2 = getN2();
    public int getN2(){
        System.out.println("AA类中getN2()被调用，普通变量初始化");
        return 200;
    }
    {
        System.out.println("AA类中普通代码块被执行");
    }

}
class BB {

}

 （3）构造器 的前面 其实是隐藏了（1） super()和（2）调用普通代码块，！！！！重要

就是·静态代码块是加载类时直接执行，然后普通代码块在创建对象时，是在构造器中隐藏的super（）后面执行的。

静态相关的·代码块，属性初始化，在类加载时，就执行完毕，因此是优先于构造器和普通代码块和普通代码块执行的

案例演示：

 

源码：

package com.cds.block;
/*
 * 构造器 的前面 其实是隐藏了 super()和调用普通代码块，
 * 静态相关的·代码块，属性初始化，在类加载时，就执行完毕，
 * 因此是优先于构造器和普通代码块和普通代码块执行的*/
public class Test04 {
    public static void main(String[] args) {
        BBB bbb = new BBB();
    }
}
class AAA{
    {
        System.out.println("AAA的普通代码块被调用");
    }

    public AAA() {
        System.out.println("AAA的构造器被调用");
    }
}
class BBB extends AAA{
    {
        System.out.println("BBB的普通代码块被调用");
    }

    public BBB() {
        //这里有隐藏的执行要求
        //(1)super()
        //(2)调用普通代码块
        System.out.println("BBB的构造器被调用");
    }
}

10.14 创建一个子类对象时，他们的静态代码块，静态属性初始化，普通代码块，普通属性初始化，构造方法的调用顺序如下

  1. 父类的静态代码块 \父类的静态属性初始化（二者优先级一样，按照定义顺序执行）
  2. 子类的静态代码块 \子类的静态属性初始化（二者优先级一样，按照定义顺序执行）
  3. 父类的普通代码块和普通属性初始化 （二者优先级一样，按照定义顺序执行）
  4. 父类的构造方法
  5. 子类的普通代码块和普通属性初始化 （二者优先级一样，按照定义顺序执行）
  6. 子类的构造方法

注意：静态代码块只能直接调用静态成员（静态 属性和静态方法），普通代码块可以调用任意成员。

源码：

package com.cds.block;


import com.sun.scenario.effect.impl.sw.sse.SSEBlend_SRC_OUTPeer;

/*
* (1)调用静态代码块和静态属性初始化
* （注意静态代码块和静态属性的优先级是一样的
* 如果有多个静态代码块和静态属性则按照他们的顺序执行）

（2）调用普通代码块和普通属性
* （注意普通代码块和普通属性的优先级是一样的
* 如果有多个普通代码块和普通属性则按照他们的顺序执行）*/
public class Test03 {
    public static void main(String[] args) {
        BB bb = new BB(18);
    }
}


class AA{
    private static int age = getAge();
    static {
        System.out.println("AA类中静态代码块被执行");
        System.out.println(AA.age);//静态代码块里面只能调用静态成员
        AA.say();//静态代码块里面只能调用静态成员
//        AA.n2;//静态代码块里面不能调用普通成员
    }

    public  static int getAge(){
        System.out.println("AA类中getAge()被调用,静态变量初始化");
        return 100;
    }

    public AA(int age) {//构造器

        System.out.println("AA类中构造器被调用");
        this.age = 10;
    }

    public static void say(){
        System.out.println("AA类中静态方法say()被执行");
    }

    public void hello(){
        System.out.println("AA类中普通方法hello()被执行");
    }
    private int n2 = getN2();
    public int getN2(){
        System.out.println("AA类中getN2()被调用，普通变量初始化");
        return 200;
    }
    {
        System.out.println("AA类中普通代码块被执行");
    }

}
class BB extends AA{
    private static int num1 = getNum1();
    private int num2  = getNum2();

    public int getNum2() {
        System.out.println("BB类的普通属性初始化");
        return 400;
    }

    public static int getNum1() {
        System.out.println("BB类的静态属性初始化");
        return 300;
    }

    static {
        System.out.println("BB类的静态代码块被调用");
    }
    {
        System.out.println("BB类的普通代码块被执行");
    }
    public BB(int age) {
        super(age);
        System.out.println("BB类的构造器被执行");
    }

}

好啦，上篇就到这里了~

马上更新下篇哦。

小柴耶
关注
  • 1
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
Java Web高级编程-（第十章源码）
03-04
它提供了一种面向对象的方式来操作数据库，简化了数据库访问。Hibernate是JPA的一个流行实现，它提供了一套强大的ORM（对象关系映射）工具。通过源码，你可以学习到如何定义实体类，使用注解进行持久化配置，以及...
第十章代码+挑战练习
12-25
在编程学习过程中，每一章通常会涵盖特定的主题，第十章可能涉及的是如数据结构、算法、面向对象编程、异常处理、多线程、网络编程、数据库交互等高级概念。挑战练习则是为了检验学习者的理解和应用能力，通常包括...
Java子类继承父类的函数调用关系及静态代码块调用
weixin_43878297的博客
07-09 836
创造一个父类 public class A { public final static String NAME="父类———："; public static String aStatic=NAME+"静态域"; public final static String aFinalStatic=NAME+"final修饰的静态域"; public static String c=NAME+"重名的静态域"; static { System.out.println(NAME+"静态代码
什么是代码块，代码块的执行顺序
weixin_52691397的博客
02-24 163
注：静态代码块时优先于普通代码块的，同样静态初始化也优先于普通初始化。Static代码块作用是对类进行初始化，并且随着类的加载而执行；普通代码块会随着创建对象实例时被隐式调用，创建一次调用一次；注：静态代码块只能调用静态成员，普通代码块可以调用任意成员。2.调用普通代码块和普通属性的初始化，谁在前执行谁；1.先调用静态代码块和静态初始化，谁在前先执行谁；只使用类的静态成员时，不会调用普通代码块。1.父类的静态代码块和静态属性。2.子类的静态代码块和静态属性。3.父类的普通代码块和普通属性。
第十章：面向对象编程（高级部分）（下）
qq_64513441的博客
06-28 208
10.15单例模式 10.15.1 饿汉式VS懒汉式 10.16 Final关键字 10.16.1基本介绍 10.16.2什么时候会使用到final关键字呢？ 10.16.3final使用的注意事项和细节讨论 10.17 抽象类 10.17.1介绍： 10.17.2抽象类的注意事项，使用细 10.18 接口 10.18.1 介绍 ：接口就是给出一些没有实现的方法封装到一起，到某个类需要使用的时候，再根据具体情况把这些方法写出来。 10.18.2 注意事项和细节 10.18.3 实现接口VS继承类 ...
java学习笔记 - 第十章：面向对象编程（高级部分）
qq_48457459的博客
03-24 393
引申 for循环快捷模板,获取当前时间的方法类变量的使用和细节，类方法的使用和细节，类方法的最佳实践，理解main方法的语法，细节和在idea中传参，代码块使用和细节，单例设计模式以及饿汉式和懒汉式，final关键字的使用和细节，抽象类的使用和细节，模板设计模式(抽象类最佳实践),接口使用和细节，接口VS继承，接口多态特性，四种内部类的使用和细节，重点是匿名内部类
第十章：面向对象高级
qq_41405475的博客
03-16 116
文章目录一、组合(一) 多继承补充(二) 组合二、三大特性之多态和鸭子类型(一)多态(二)鸭子类型三、绑定方法与非绑定方法(一)绑定方法(二)非绑定方法四、反射五、内置方法 一、组合 (一) 多继承补充 class People: school = 'qinghua' def __init__(self,name,age,gender): self.name = name self.age = age self.gender = gender
第十章面向对象编程（高级部分）
qq_39667860的博客
01-11 593
思考: 如果,设计一个 int count 表示总人数,我们在创建一个小孩时，就把 count 加 1,并且 count 是所有对象共享的就 ok 了!类名.类方法 或者 对象名.类方法名（前提是要符合访问修饰符的访问权限）如果定义类在局部位置(方法中/代码块) :(1) 局部内部类 (2) 匿名内部类。//父类类型的变量 a 可以指向 继承 AAA 的子类的对象实例。定义在成员位置 (1) 成员内部类 (2) 静态内部类。（2）static类变量，咋类加载的时候就生成了。
第十章 面向对象编程（高级部分）
SUPER_HEROs的博客
11-30 197
第十章 面向对象编程（高级部分） 10.1 类变量 类变量也叫静态变量/静态属性，是该类的所有对象共享的变量，任何一个该类的对象去访问他，取到的都是相同的值，同样任何一个该类的对象去修改它时，修改的也是同一个变量。 (1)static 变量是同一类所有对象共享 (2)static类变量，在类加载的时候就生成了 //定义语法： 访问修饰符 static 数据类型 变量名;【推荐】 static 访问修饰符 数据类型 变量名; //如何访问类变量 类名.类变量名 或者 对象
Java第十章：面向对象高级
m0_74087660的博客
11-04 142
java第十章：面向对象高级部分：类变量和类方法使用、main方法详解、代码块使用、单例模式、final关键字、抽象类、接口、内部类
第十章 面向对象编程（高级）
yirenyuan的博客
06-28 953
一、类变量和类方法 | 二、理解 main 方法 | 三、代码块 | 四、final 关键字 | 五、抽象类 | 六、接口 | 七、内部类 |
vb高级编程Transparancy完美版资料.ppt
11-16
第十三至第十五章：涉及更高级的主题，如使用`Printer`、`Screen`和`ClipBoard`对象，面向对象编程，以及使用类和ActiveX控件。还讲解了Win32API的使用，以实现与操作系统的交互，数据库控制对象的使用，以及网络...
JavaScript第十章完整案例
05-29
在JavaScript的第十章，通常会涵盖诸如DOM操作、事件处理、AJAX异步通信、闭包、模块化编程、面向对象编程等关键概念。DOM（Document Object Model）是HTML和XML文档的结构化表示，通过JavaScript，我们可以轻松地...
java springboot 集成 阿里通义千问
qq_25987725的博客
07-25 391
一、在阿里云https://www.aliyun.com官网直接搜索“通义千问”，点击“开通DashScope”进行服务激活。四、在config目录添加配置 TongYiAiConfiguration.java。三、在yml中配置中配置key。二、加入Maven依赖。
使用hutool工具判断字符串是否全部是字母(包括大小写)，java判断字符串是否全部是字母(包括大小写)
最新发布
qq_43700885的博客
07-29 443
1.导入hutool的maven依赖。2.复制一下代码执行。
java判断邮箱地址是否正确，使用hutool工具判断邮箱地址是否正确
qq_43700885的博客
07-29 242
1.导入hutool的maven依赖。2.直接复制一下代码运行。
Swagger使用Map接受参数时，页面如何显示具体参数及说
a1058926697的博客
07-26 616
后端使用Map接受参数，要求在swagger页面上显示具体的参数名称、类型及说明。当Map接受参数数量少时，可以使用Swagger自带的注解。自定义注解 @ApiGlobalModel。编写处理注解对应的插件。
C++语言详解：面向对象编程入门与进阶
C++语言设计是一本详尽的教程，专为初学者到高级开发者提供全面的指导，从C语言的基础出发，深入探讨面向对象编程（Object-Oriented Programming，OOP）的理念。这本书历经多版更新，尤其第4版在前版基础上做了重大...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值