张小飞的Java之路——第九章

article/2025/9/10 15:56:47

写在前面：

视频是什么东西，有看文档精彩吗？

视频是什么东西，有看文档速度快吗？

视频是什么东西，有看文档效率高吗？


诸小亮：“封装说完后，我们接着看面向对象的第二大特征——继承”

张小飞：“跟我们生活中继承是一样的？”

诸小亮：“当然，计算机中的一切都是从生活中来的”

1. 介绍

1. 生活中的继承

诸小亮：“首先，我们看下生活中的继承”

张小飞：“这有啥了解的，不就是儿子继承老爹的家产么”

“…，我说的继承不是这个”

“嗯？那你说的是？”

“生活中有：小学生、大学生、小学老师、大学老师这些类别”

“何止啊，还有：男人、女人、好人、坏人这些呢”

“…，不要插嘴，听我说：小学生、大学生 拥有很多共同点，可以统称为：学生”

“嗯嗯，学生是一个更大的分类”

“同样的，小学老师、大学老师 也拥有很多共同点，可以统称为：老师”

“师兄，照你这么说，老师、学生 也有很多共同点，可以统称为：人”

“你说的很对，如果用一张图来表示它们之间的关系：”
image.png
所谓继承：不同分类可以向上抽取共同点，形成一个更大的分类（也叫：父类）

张小飞：“原来这就是继承”

2. Java中的继承

诸小亮：“Java 中的继承也一样，先看两个类：”

class Student{int age;
}class Teacher{int age;
}

张小飞：“很明显：这两个类的共同点是：年龄”

诸小亮：“没错，所以可以向上抽取，创建一个新的类：”

class Person{int age;
}

张小飞：“那，怎么表示继承关系呢？”

诸小亮：“在 Java 中用 extends 来表示继承关系，比如：”
image.png
“这时，Student称为：子类，Person称为：父类”

张小飞：“原来如此”

2. 继承的特点

张小飞：“但是这个继承有什么用呢？”

诸小亮：“java中，一旦两个类出现继承关系，子类自动继承父类的所有成员”

class Person{int age;void show(){System.out.println(this.age);}
}//继承Person后，不需要声明任何属性和方法，继承父类属性和方法
class Student extends Person{}public class Demo{public static void main(String[] args){//这时候，s 即是 Student 类型，也是 Person 类型Student s = new Student();//子类对象可以直接使用父类中的属性和方法s.age = 18;s.show();}
}

诸小亮：“你觉得这样有什么好处？”

张小飞：“好处嘛，提高代码的复用性？”

诸小亮：“你说的不错，就是这样”

诸小亮：“但是需要注意：Java中，只有单继承，没有多继承”

张小飞：“这是什么意思？”

诸小亮：“也就是说：一个类只能有一个父类，比如：”
image.png
张小飞：“这是为啥？”

诸小亮：“这还用问？你有俩爹吗？”

“…，我是想问Java中为什么不能多继承”

“如果一个类有两个父类，且这两个父类又都有 show 方法，你觉得子类应该继承的是哪个？”

“嗯…，这个，不能同时继承吗？”

“你这样问，就是还没明白什么是继承？继承父类的成员，就相当于再子类中定义了这些成员一样”

class Person{int age;void show(){System.out.println(this.age);}
}class Student extends Person{//Student继承Person后，就相当于再 Student 中定义了 age 属性，和 show 方法/*int age;void show(){System.out.println(this.age);}*/
}

张小飞：“原来是这样，一个类中不允许同时存在多个相同的方法”

诸小亮：“但是，允许多层次继承”

张小飞：“这又是什么意思？”

“来，看下面代码：”

class Person{int age;void show(){System.out.println(this.age);}
}class Student extends Person{
}//Pupil 继承Student，而Studen又继承Person，所以Pupil拥有Person的属性和方法
class Pupil extends Student{}
public class Demo2{public static void main(String[] args){//这时候，pp 即是 Pupil 类型，也是 Student 类型，还是 Person 类型Pupil pp = new Pupil();pp.age = 18;pp.show();}
}

张小飞：“原来还可以这样，那，这时候 Person 是爷爷类？”

诸小亮：“额…，是这样没错，不过我们一般统称 Student 和 Person 都是父类”

张小飞：“好吧”

诸小亮：“最后一点：当事物之间存在所属关系时，才可以使用继承”

张小飞：“额…，完全不懂”

诸小亮：“具体来说：如果一个类需要具备另一个类的 所有成员 时，才可以使用extends，比如：”

class Dog {//奔跑void run(){}//看家void kanjia(){}
}
class Cat extends Dog{//这种继承是不允许的，因为猫不能看家
}

张小飞：“但是，如果 Cat 类想继承 run 方法，怎么办？”

诸小亮：“那就继续向上抽取，比如：”

class Animal {//奔跑void run(){}
}
class Dog extends Animal{//看家void kanjia(){}
}
class Cat extends Animal{
}

张小飞：“明白了”

3. 继承时，成员的特点

诸小亮：“Java中使用继承时，继承的成员也有一些特点”

张小飞：“哦？什么特点？”

1. 成员变量

诸小亮：“普通成员变量都可以被继承，但是私有属性。。。。。”

张小飞：“怎么，私有属性不能被继承？”

1. 私有属性

诸小亮：“可以被继承，不过先看代码吧”

class Person{private String name;//私有属性int age;
}
class Student extends Person{
}

“private只是访问权限修饰符，不影响继承关系，所以 Student 仍然可以继承name属性”

张小飞：“那，问题是什么呢？”

诸小亮：“你忘了？name 是私有的，所以不能在外界访问（只能在 Person 中访问）”

张小飞：“你说的是这个，这简单，在 Person 中提供 get、set方法，不就行了”

诸小亮：“嗯，你说的不错，所以这也不是很大的问题，你明白就行”

2. super 关键字

诸小亮：“接下来，我们看 super 关键字”

张小飞：“这是做什么用的？”

诸小亮：“还是先看代码，你觉得下面的代码输出结果是什么？”

class Person{//1. Person中定义一个 name 属性String name = "人类";int age;
}
class Student extends Person{//2. Student 继承 Person，但是也定义一个 name 属性String name = "学生";void show(){//3. 方法中定义一个 name 局部变量String name="亚瑟";//4. 输出 name 的值System.out.println(name);}
}
public class Demo2{public static void main(String[] args){Student s = new Student();//5. 调用show方法s.show();}
}

张小飞：“这很简单啊，输出的肯定是 ‘亚瑟’”

“为什么输出的不是 ‘学生’呢？”

“想要输出‘学生’得用 this 关键字吧，比如：”
image.png
“问题就在这里，使用 this.name 输出的到底是 ‘学生’还是‘人类’呢？”

“这个…，我来试试”

张小飞：“师兄，输出的是‘学生’，这表示没有继承 Person 的 name 属性吗？”

诸小亮：“当然不是了，这种情况下想使用父类中定义的属性，得用 super，比如：”
image.png

张小飞：“果然，不过这是为什么呢？”

诸小亮：“Student 继承了 Person 中的 name ，但是 Student 中已经有了 name”

  • 为了区分 子父类 中的同名属性，需要使用this、super
  • 注意：真实开发中不应该出现子父类属性名一样的情况

张小飞：“明白了”

2. 成员方法

1. 方法覆盖

诸小亮：“刚才我们说的是属性，其实，方法也可能重复，比如：”

class Person{void show(){System.out.println("Person 中的方法。。。。。。");}}
class Student extends Person{//子类中出现了跟父类中一样的方法void show(){System.out.println("Student 中的方法。。。。。。");}
}
public class Demo2{public static void main(String[] args){Student s = new Student();s.show();}
}

张小飞：“还可以这样，我试试，看结果是什么”
image.png

“师兄，如何解释上面的输出？”

“当 子父类 中出现一样的方法时，称为：覆盖（override），也叫：重写 或 复写”

  • 这时，子类对象调用方法，最终运行的是自己的方法

“这是一种正常现象，开发中经常使用，父类中的功能不是自己想要的，可以重写此功能，比如：”

//定义 Phone 类，有两个功能：call、show(来电显示手机号)
class Phone{void call(){}void show(){System.out.println("来电显示手机号。。。。。。");}}

张小飞：“这，啥都没看出来”

诸小亮：“不要急嘛，如果需求改变：不仅显示手机号，还要显示姓名，这时不建议修改原来的功能，而是新建一个子类重写该功能，比如：”

class newPhone extends Phone{void show(){//如果还需要父类的功能，通过super调用，这样通过复写，就扩展了功能super.show();System.out.println("显示姓名。。。。。。");}
}

张小飞：“为什么不直接在 Phone 中修改代码呢？”

诸小亮：“因为：Phone中的 show 方法可能已经被很多地方使用，修改后会可能造成很大的影响”

“原来是这样，我记下了”

“这个——不用记”

“嗯？”

“理论上是这样，但是工作中都是直接修改 Phone 中的 show 方法”

“…，那你给我讲这个干嘛？”

“这不是为了给你解释‘方法覆盖’嘛”

“好吧，我明白了”

2. 注意点

诸小亮：“使用 方法覆盖 时，还需要注意一些地方”

张小飞：“都需要注意什么？”

“第一：子类方法访问权限需大于等于父类方法，否则编译报错，比如：”
image.png
“师兄，public 这个我知道，但是 newPhone 中的 show 方法，没有修饰符啊”

“这个确实还没说过，如果没有修饰符，那么就是默认的default，比 private 高，比 public 低，之后会专门介绍访问权限的”

“好的，好的”

“第二点：静态只能覆盖静态，否则编译报错，比如：”

image.png
“上图提示：newPhone 中的静态方法 show，不饿能覆盖 Phone 中的实例方法 show”

3. 构造函数

诸小亮：“继承时候，构造函数也有一些地方需要注意”

张小飞：“都有哪些地方呢”

“第一点：创建子类对象的时候，父类的构造函数也会运行，比如：”

class Person{Person(){System.out.println("父类构造函数。。。。。");}
}
class Student extends Person{Student(){System.out.println("子类构造函数。。。。。");}
}
public class Demo2{public static void main(String[] args){//创建 Student 对象时，Person 的构造函数也会执行new Student();}
}

结果：
image.png
张小飞：“为啥会运行？”

诸小亮解释道：“因为在子类构造函数中，默认的第一行是** super(); **调用了父类的构造函数”

“没有在代码中看到 super(); 啊”张小飞疑惑道

“有的，只是没有显示出来而已”

“那，这样是不是也创建出了一个 Person 对象？”

“不会的，调用父类构造函数的目的：初始化子类继承的属性，并不会创建一个父类的对象”

“哦，原来是这样”

“师兄，还有一个问题，如果父类中没有空参数的构造函数呢？”

“这就是我要说的第二点：这时代码会编译报错”
image.png
“那该如何解决呢？”

“在子类中需要显式的调用就行了，比如：”
image.png
注意：super 必须放在第一行，因为父类构造函数需要先运行

4. final

诸小亮：“接着我们学些——final 关键字”

张小飞：“这个我知道，final 是最终的、不可更改的意思，对吧”

“嗯…，中文翻译是没错，不过我要说的是，它用来可以修饰：类、方法、变量”

“修饰就修饰呗，难道还有什么影响？”

“聪明，用 final 时候确实需要注意一下”

“第一：final 修饰的类不可被继承，比如：”
image.png
“为啥不让继承啊”张小飞问道

“官方的说法：为了保证某些类的稳定性和安全性，防止出现一些意外的情况和错误”

“…，能不能说的简单些？”

“有些人就是不想有儿子，所以把自己结扎了，这样明白不？”

“哈哈，明白，明白”

“第二：final 修饰的方法不可被覆盖，比如：”
image.png
“这个又是为什么？”

“防止子类在不经意间修改父类的方法，从而破坏程序的正确性”

“好吧”

“第三：final 修饰的变量不可更改，比如：”
image.png
“上图提示，不能对final修饰的变量进行修改，另外：一般使用final定义的变量都应该是大写字母”

“这是为什么？”

“因为——这样显的更加专业” 诸小亮回答道

“…”

“师兄，为什么我这里可以改？”
image.png
“这就是我要说的最后一点：”

  • 如果修饰的是一个对象，可以修改对象的属性，但不能让它指向一个新的对象

比如：
image.png
“能否具体解释一下？”

“好吧，首先你得明白，final 修饰的是 p 而不是 name 属性”

“嗯嗯，这个我知道”

“p 的值是一个内存地址，而 p = new Person(); 表示让 p 指向新的内存地址，所以报错
而 p.name=“冯先生”，只是修改对象里面的属性，并不会更改 p 的值，所以可以修改成功”

“原来如此”

5. 抽象类

诸小亮：“接下来就介绍一些——抽象类”

张小飞：“什么叫——抽象类”

1. 介绍

诸小亮：“抽象：就是笼统，笼统就是信息不完善，无法具体描述”

张小飞：“Java不是可以描述世间万物吗，有什么是不能描述的？”

“你说的不错，不过总有例外，比如：现实中，动物都能吼叫，这你知道吧”

“废话，不会叫的是王八”

“哟，看你厉害的，那你给我说说，动物是怎么叫的”

“额…，你这个问题就不对，哪有这样问的”

“不行了吧，看我的，如果用常规的方法写一个类描述动物”

//定义一个 Animal 类，有一个 sound 的功能
class Animal{void sound(){//无法描述动物是怎么叫的}
}

张小飞白了一眼，说道：“你还不是一样，写不出来嘛”

诸小亮：“但是可以用子类复写啊，比如：”

class Animal{//定义一个 Animal 类，有一个 sound 的功能void sound(){//在方法中，我们无法描述动物是如何吼叫的，因为每种动物都不同，只有在子类中复写}
}
class Dog extends Animal{void sound(){System.out.println("汪汪汪。。。。。");}
}
class Cat extends Animal{void sound(){System.out.println("喵喵喵。。。。。");}
}

张小飞：“但是，Animal 中有个 sound 方法中没有内容，不是没有意义吗？”

诸小亮：“所以，当一个功能无法具体描述，但是又不可缺少的时候，就要把它写成抽象方法”
“上面代码， sound 方法无法具体描述，但是又不可缺少，这时就要用抽象”

//抽象方法：使用 abstract 修饰，没有方法体，直接分号结束
abstract void sound();

“另外，如果一个类中有抽象方法，那么这个类肯定是：抽象类”，比如：

//抽象类：也是使用 abstract 修饰
abstract class Animal{abstract void sound();
}

张小飞：“原来是这样”

诸小亮：“注意：抽象类无法创建对象”

张小飞：“嗯？那有什么用”

“目的：声明抽象方法，让子类复写”

“好吧，不过子类必须的实现父类的抽象方法吗？”

“不是必须的，如果子类不想父类的所有抽象方法，那么子类也应该是一个抽象类”
image.png
上图提示：Dog 中没有复写 Animal 的 sound 方法，也应该是一个抽象类

张小飞“那，抽象类中只能有抽象方法吗？”

诸小亮：“不一定，也可以又具体的方法，比如：”

abstract class Animal{void eat(){System.out.println("动物都是用嘴吃饭。。。。。");}
}

张小飞：“这又是为什么，难道是为了让子类继承？”

诸小亮：“又让你猜对了”

张小飞：“…”

诸小亮：“我们总结一下：”

  • 抽象类和抽象方法都需要使用 abstract 修饰
  • 抽象类中可以写具体的方法
  • 抽象类不能使用new创建对象
  • 如果子类没有复写父类的所有抽象方法，那么子类也应该是一个抽象类

2. 一些细节（了解）

诸小亮：“再给你说一些细节的东西吧，了解一下就行”

  • 抽象类中有构造函数，目的：给子类对象进行初始化
  • 抽象类一般都应该有子类，没有子类的抽象类没有意义
  • 抽象类中可以没有抽象方法，都是具体的方法，目的：不让它创建对象

诸小亮：“另外，关于 abstract 关键字也有一些注意点”

第一：不能和 final 同时修饰一个类，否则编译报错，比如：
image.png

第二：不能和 private 或 static 修饰同一个方法，否则编译报错，比如：
image.png

第三：不能和 default 修饰同一个方法（JDK 8的新特性，讲接口时再说）

3. 接口

张小飞：“这个接口是？？？”

诸小亮：“来，先给你介绍一下”

1. 介绍

诸小亮：“当一个抽象类中的所有方法都是抽象的，那么它就是个接口，比如：”

//接口：使用 interface 修饰
interface Animal{abstract void sound();abstract void eat();
}

“你可以这样认为：接口——就是一种特殊的抽象类”

“具体是怎么特殊呢？”

“接口一般中的成员有固定修饰符”

“固定修饰符？”

“没错，接口中的成员默认就是 public，而且必须是 public，所以可以省略，比如：”
image.png

“而且，如果用其他修饰符，会报错，比如：”

image.png
张小飞“原来是这样”

“还有，接口中的方法默认就是抽象方法，所以 abstract 关键字也可以省略
image.png
张小飞：“所以说，public 和 abstract 就是接口中方法的固定修饰符？”

诸小亮“是的，不仅是方法，接口中的变量也都是 final 且 static 的，比如：”

image.png
上图提示，Animal 中的 num 是 final 的，不能修改

张小飞：“明白了，这样的话，接口的定义完全可以简化，比如：”

interface Animal{int NUM = 100;void sound();void eat();
}

“不过，接口具体有什么用呢？”

“工作中，一般用接口来定义全局常量，毕竟它默认是 public 且 final 且 static 的嘛”

“嗯，这个我明白，那它的抽象方法呢？”

“这就跟抽象类差不多了，都是给子类用的”

2. 接口的子类

诸小亮：“接口不能创建对象，定义它目的：让子类去实现”

张小飞：“实现？不是继承吗？”

“接口这里不叫继承，而是通过 **implements **关键字去实现接口，比如：”
image.png

“另外，子类需要实现接口中的所有抽象方法，否则它也应该是个抽象类，比如：”

image.png
上图提示：必须实现每一个抽象方法，或者声明Dog是抽象类

张小飞：“这样看来，接口还不如抽象类呢，用抽象类还能继承一些东西”

诸小亮：“这你就错了，接口最大的好处就是：一个类可以同时实现多个接口”

“还可以这么玩儿？”

“当然，其目的：弥补不能多继承的缺陷，比如：”
image.png
“另外，在实现接口的同时，也可以继承其他类”
image.png
张小飞：“原来还可以这样”

诸小亮：“最后一点：接口可以有子接口，它们之间是继承关系，比如：”

interface Animal{void sound();
}
//BigDog继承了Animal，那么它就继承了Animal的sound方法
interface BigDog extends Animal{void eat();
}
//Dog实现BigDog，所以要实现两个方法
class Dog implements BigDog {@Overridepublic void sound() {}@Overridepublic void eat() {}
}

张小飞：“好的，我记下了”

3. default

诸小亮：“其实，接口中也可以定义具体的方法”

张小飞：“不是说只能定义抽象方法吗？”

“那是JDK 8之前的事了，从 JDK 8 开始，接口通过 default 关键字可以定义具体的方法，比如：”

interface Animal{//使用 default 可以定义具体的方法default void run(){System.out.println("动物在奔跑。。。。。");}
}

“同时，接口的子类可以继承 defualt 方法，比如：”

interface Animal{//1. 使用 default 可以定义具体的方法default void run(){System.out.println("动物在奔跑。。。。。");}
}
class Dog implements Animal{
}
public class Demo{public static void main(String[] args){//2. Dog直接继承run方法，所以它的对象可以直接调用new Dog().run();}
}

结果：
image.png
张小飞：“这样说的话，抽象类就没啥用了”

诸小亮：“你说的不错，所以现在工作中大多数都用接口，我这么多年也没用过抽象类”

“如果一个类实现了俩接口，它们又有相同的default方法，这样是继承哪个？”

“这种情况下，子类么必须进行复写，比如：”
image.png
上图提示：Dog不知道从哪个接口中继承run方法，所以必须复写

张小飞：“原来如此，那如果是这样呢？”

比如：Dog 继承了 BigDog，并实现 Animal 接口，而 BigDog 和 Animal 有相同的方法

interface Animal{default void run(){System.out.println("动物在奔跑。。。。。。");}
}class BigDog{public void run(){System.out.println("大狗在奔跑。。。。。。");}
}class Dog extends BigDog implements Animal{
}

诸小亮：“这个，你运行一下，就可以得到答案了”

30秒后。

张小飞：“原来是继承优先”

public class Demo {public static void main(String[] args) {//Dog 最终继承的是 BigDog 中的方法new Dog().run();}
}

结果：image.png

4. 静态方法

诸小亮：“最后一个知识点了——静态方法”

张小飞：“接口中也可以定义静态方法？”

“是的，可以定义静态方法，使用方式：接口名.方法名，比如：”

interface Animal{default void run(){System.out.println("动物在奔跑。。。。。。");}static void eat(){System.out.println("动物都会吃东西。。。。。。");}
}public class Demo {public static void main(String[] args) {Animal.eat();//调用接口中的静态方法}
}

“好了，这样我们就说完了，你先回顾一下，一会儿我们做个总结”

5. 总结

十分钟后。

诸小亮：“师弟，能简单的总结一下接口吗？”

张小飞：“我试试”

  • 接口是一种特殊的抽象类，使用 interface 修饰
  • 接口中的方法全是 public 且 abstract 的
  • 接口中的变量全是 public 且 final 且 static 的（其实就是常量）
  • JDK 8 开始可以通过 default 在接口中定义具体的方法
  • 另外，接口中也可以定义静态方法

诸小亮：“嗯，不错，记住这些就够了，刚好也中午了，咱就先休息一下”

张小飞：“早就等着你这句话呢”


http://chatgpt.dhexx.cn/article/OD1Gtxq7.shtml

相关文章

Java设计模式（2 / 23）：观察者模式

Java设计模式（2 / 23）：观察者模式

定义 观察者（Observer）模式定义了对象之间的一对多依赖，这样一来，当一个对象改变状态时，它的所有依赖者都会收到通知并自动更新。 OO设计原则：为了交互对象之间的松耦合设计而努力。 案例：气…
阅读更多...
大聪明教你学Java设计模式 | 第十三篇：观察者模式

大聪明教你学Java设计模式 | 第十三篇：观察者模式

前言 🍊作者简介： 不肯过江东丶，一个来自二线城市的程序员，致力于用“猥琐”办法解决繁琐问题，让复杂的问题变得通俗易懂。 🍊支持作者： 点赞👍、关注💖、留言&#x1f4…
阅读更多...
Java 设计模式（十三）：代理模式

Java 设计模式（十三）：代理模式

参考链接：代理模式-Proxy Pattern 近年来，代购已逐步成为电子商务的一个重要分支。代购简单来说就是找人帮忙购买所需要的商品，代购网站就是其中一种产物，它为消费者提供在线的代购服务，如果看中某国外购物网站上的商…
阅读更多...
Java设计模式：观察者模式

Java设计模式：观察者模式

一、什么是观察者模式？ 又叫做发布-订阅模式，定义对象间一种一对多的依赖关系，使得每当一个对象改变状态，则所有依赖于它的对象都会得到通知并自动更新。UML结构图如下： 其中涉及到四种角色： 1.抽象目标&a…
阅读更多...
初探Java设计模式------观察者模式

初探Java设计模式------观察者模式

前言 最近刚开始学习RxJava，众所周知，Rxjava就是扩展的观察者模式，所以想学习Rxjava，先入手了解一下观察者模式是很有必要的。那么今天就先稍微了解一下什么是观察者模式。 定义 观察者(Observer)模式：是对象的行为模…
阅读更多...
java设计模式（3）--观察者模式

java设计模式（3）--观察者模式

（一）观察者模式 观察者模式定义对象间的一种一对多的依赖关系，当一个对象的状态发生改变时，所有依赖于它的对象都得到通知并被自动更新。 该模式有以下角色： （1）抽象主题（Subjec…
阅读更多...
Java设计模式之行为型：观察者模式

Java设计模式之行为型：观察者模式

一、什么是观察者模式： 观察者模式又称为 发布-订阅模式，定义了对象之间一对多依赖关系，当目标对象(被观察者)的状态发生改变时，它的所有依赖者(观察者)都会收到通知。一个观察目标可以对应多个观察者，而这些观察者之间…
阅读更多...
java监听设计模式（java观察者设计模式）

java监听设计模式（java观察者设计模式）

今天给大家分享一下观察者设计模式（监听设计模式），该模式在很多主流得框架、源码中使用率非常高。在分享之前先给大家讲一个我们使用手机的一个场景，我们都用过手机，当我们手机来电话的时候，会有各种复杂的…
阅读更多...
【十一】设计模式~~~结构型模式~~~代理模式（Java）

【十一】设计模式~~~结构型模式~~~代理模式（Java）

【学习难度：★★★☆☆，使用频率：★★★★☆】 6.1. 模式动机 在某些情况下，一个客户不想或者不能直接引用一个对 象，此时可以通过一个称之为“代理”的第三者来实现 间接引用。代理对象可以在客户端和目标对象之间起…
阅读更多...
JAVA架构之路（设计模式之观察者模式）

JAVA架构之路（设计模式之观察者模式）

设计模式之观察者模式 定义：对象间的一种一对多的依赖关系，当一个对象的状态发生改变时，所有依赖于它的对象都得到通知并被自动更新 核心原理： 1.被观察者中维护一个观察者对象列表 2.观察者可新增可可移除。 需要角色&#…
阅读更多...
程序员百宝箱---搭建自己专属的在线工具集

程序员百宝箱---搭建自己专属的在线工具集

相信各位开发者/程序员在开发过程中都使用过各种在线工具吧。比如 1 校验或格式化 json 字符串 2 使用 base64 的加密解密，url 的编码解码 urlencode、urldecode 等 3 调试正则表达式是否正确 4 时间戳与格式化日期互相转换 5 文本对比，比较两个代码文件…
阅读更多...
如何部署JSP应用到阿里云服务器上（一）

如何部署JSP应用到阿里云服务器上（一）

今天讲解一下如何部署JSP应用到阿里云服务器上，我使用的后台服务器是 Tomcat服务器，服务器应用的开发语言是 Java Web ，后台的数据库使用的是MySQL 1 打开阿里云官方网站 https://www.aliyun.com/?utm_mediumtext&utm_sourcebdbrand&am…
阅读更多...
开源项目精选推荐-杨小杰工具箱(YoungxjTools)

开源项目精选推荐-杨小杰工具箱(YoungxjTools)

演示 预览地址： https://tools.yum6.cn/ 程序介绍 01、首页底部友情链接 02、网站公告页面功能 03、内置留言管理功能 04、后台网站信息设置 05、内置smtp发信配置 06、支持两主题的切换 07、关于页面支持留言， 08、程序已集成32种小工具 更多功能 介绍 请搭建 自行测试
阅读更多...
C++构造函数之初始化列表

C++构造函数之初始化列表

C构造函数之初始化列表 构造函数可以说是对于C每个类来说最重要的组成部分，之前也详细介绍过构造函数的相关知识，今天给构造函数进行补充，主要说明一下构造函数的初始值列表 一、初始化列表的写法 仍然以之前介绍构造函数时使用的学生类来…
阅读更多...
C++初始化列表详解

C++初始化列表详解

目录： 定义 使用初始化列表的原因 必须使用初始化列表的时候 成员变量的顺序 定义 与其他函数不同，构造函数除了有名字，参数列表和函数体之外，还可以有初始化列表，初始化列表以冒号…
阅读更多...
C++类的初始化列表

C++类的初始化列表

意义 初始化列表是类中构造函数的一部分，用于实例化类中变量时 赋初值。 需要先了解 构造函数的基本知识。CSDN-构造函数https://blog.csdn.net/weixin_44212838/article/details/124901019?spm1001.2014.3001.5501 用法 在函数头与函数体之间，用一…
阅读更多...
详解初始化列表

详解初始化列表

初始化列表 定义 构造函数有个特殊的初始化方式叫“初始化表达式表”（简称初始化列表）。初始化列表位于函数参数表之后，却在函数体 {} 之前。这说明该表里的初始化工作发生在函数体内的任何代码被执行之前。 Date(int year, int month, in…
阅读更多...
C++ 成员初始化列表

C++ 成员初始化列表

这里写目录标题 数据成员是某一个类的对象，且这个类没有默认构造函数数据成员的类型是const或者引用子类初始化父类初始化列表先后顺序使用成员初始化列表的优点 在以下三种情况下需要使用初始化成员列表： 需要初始化的数据成员是某一个类的对象&#xf…
阅读更多...
【深入理解】初始化列表

【深入理解】初始化列表

目录 一、什么是初始化列表？ 二、初始化列表长啥样？ 三、初始化列表的特性 1、由于是在定义阶段进行的初始化，所以，只能在定义阶段进行的初始化类型便只能在初始化列表中进行初始化。 2、初始化顺序不是跟着初始化列表走的&#x…
阅读更多...
C++ 初始化列表详解

C++ 初始化列表详解

目录 1.什么是初始化列表 2.什么时候需要使用初始化列表？ 3.初始化列表的效率 4.初始化列表的初始化顺序 1.什么是初始化列表 class A { public:A(int value):m_dada(value){}private:int m_dada; }; 如上图，红色圈起来的部分，就是构造函…
阅读更多...
推荐文章

Copyright @ 2022~2023