本文详细讲解了Java中类的分类，包括实体类、工具类和主类。接着讨论了静态变量与成员变量的区别，如生命周期、调用方式和存储位置。还介绍了代码块的概念，如局部代码块、构造代码块和静态代码块的作用。此外，文章阐述了继承的基本原理，强调了子类与父类成员变量和函数的调用规则。接着介绍了抽象类和多态的概念，以及多态的实现和注意事项。最后，探讨了单例模式的设计思想及其在限制对象唯一性方面的应用。
6.10类的分类
1、实体类
类中的内容基本上都是成员函数或成员变量，也存在静态成员
2、工具类
提供已经被实现的功能，并向外部供应，基本上都是静态函数
运用静态的原因：
- 共有
- 存在时间长
- 只需要加载一次，后续可随意使用
3、主类（测试类）
主要用于运行/测试代码，这个类中会有主函数的存在
实体类是可以存在主函数的
工具类一般不会存在主函数
6.11 静态变量与成员变量的区别
1.生命周期
成员变量随着对象的创建而创建 随着对象的消亡而消亡
静态变量随着类的加载而创建 随着程序结束而消失
2.调用方式
成员变量必须先创建对象 在通过对象去调用
静态变量可以被对象调用 也可以直接用类调用
3.存储位置
成员变量存在于堆内存中对象的所属空间里
静态变量存在于静态方法区中类的所属空间里
4.命名
成员变量-对象的特有属性
静态变量-对象的共有属性 类成员
6.12 代码块
1、代码块：
{。。。}
2、局部代码块：
存在于函数当中；for(){...} if(){...}
3、构造代码块：
直接在类中出现的{...}
当对象创建一次 构造代码块执行一次
作用：等同于构造函数
4、静态代码块：
直接在类中出现的static{...}
当类被加载的时候，仅且只执行一次
作用：对类进行一些初始化操作
6.13继承
我们在写几个类的时候，有时候这个几个类会有相同的属性和行为，所以我们就可以把这些相同的属性和行为单独成为一个类，其他类继承这个类的属性和行为，在其他类中就不用写这些属性和行为了。我们用extends关键字来继承父类。java的类与类之间只能是单继承关系，一个父类可以有多个子类，但是一个子类只能拥有一个父类。
在java中所有类的最终的父类是Object!
我们在一个函数继承于另一个函数的时候，子父类中成员变量/静态变量的特点：如果只有子类有且非私有，那么就调用子类的
，如果只有父类有且非私有，那么就调用父类的，如果子父类都有且非私有 那么就调用子类的，(成员变量之间 是不存在重写关系的!!!)。
调用顺序：子类对象成员->子类静态->父类成员->父类静态
我们在运行子类构造函数的时候，会默认执行super()；函数，来运行父类的构造函数，因为我们子类需要用到父类的变量或者函数，所在super必须在子类构造函数执行之前执行。
注意：super来调用父类的构造函数不代表就创建了父类的对象，只是父类空间的引用。
如果在调用子类构造函数的时候传递了参数，我们需要自己去用super(...)去调用父类的构造函数。
子父类中成员函数的特点：
- 如果只有子类有且非私有 那么就调用子类。
- 如果只有父类有且非私有 那么就调用父类的。
- 如果子父类都有且非私有 那么就调用子类的（函数重写）
class ExtendsDemo02{
public static void main(String[] args){
Zi zi=new Zi();
System.out.println(zi.num1);//20
System.out.println(zi.num2);//30
System.out.println(zi.num3);//50
zi.show();
zi.sing();
}
}
//子父类中成员变量的特点
/*
class Grandfather{
int num1=100;
int num4=200;
}
*/
class Fu {//extends Grandfather{
int num1=10;
static int num2=40;
static int num3=50;
Fu(){
super();//Object(){} 显示初始化父类空间中的成员变量
System.out.println("Fu constructor1......");
}
Fu(int num){
System.out.println("Fu constructor2......");
}
void sing(){
System.out.println("Fu sing......");
System.out.println("爸爸我会唱红歌");
}
}
class Zi extends Fu{
int num1=20;
static int num2=30;
Zi(){
this(0,0);
System.out.println("Zi constructor1......");
}
Zi(int num1){
this(0,0);
System.out.println("Zi constructor2......");
}
Zi(int num1,int num2){
super();
System.out.println("Zi constructor3......");
}
void show(){
//局部变量和成员变量如果重名了 this区分
System.out.println(num1+","+num2+","+num3);
//局部变量/成员变量和父类变量重名了 super区别 super.xxx => 你爸爸的xxx
System.out.println(super.num1+","+super.num2+","+num3);
//System.out.println(super.super.num1);
//System.out.println(num4);
}
@Override
void sing(){
System.out.println("Zi sing......");
System.out.println("儿子我会唱摇滚、民谣、爵士、蓝调、电子");
}
}函数重写是在子父类中，同名函数， 函数有什么组成：函数声明(权限 类型 返回值类型 函数名 参数列表)+函数体({}里面的内容)
重写的意义在于哪？在于子类继承了父类的函数声明(功能)，但是子类可以将该函数的具体实现进行优化或更改。
我们在函数重写中需要注意到的细节：
- 函数重名，但是参数列表不同，不构成重写关系。
- 函数重名，参数列表相同，返回值也相同，才构成重写关系。
- 子类重写父类的函数的时候，它的权限必须>=父类的权限。
- 如果父类的权限为private，子类本来就用不到，也不叫重写。
class ExtendsDemo03{
public static void main(String[] args){
IPhoneXPlusProMax iniuB=new IPhoneXPlusProMax();
iniuB.call();
iniuB.open5G();
Zi zi=new Zi();
zi.show(10);
zi.show();
}
}
class Fu{
void show(){
System.out.println("Fu show...");
}
private void haha(){} //去洗头房
}
class Zi extends Fu{
//不是重写的
void show(int num){
System.out.println("Zi show1...");
}
public void show(){
System.out.println("Zi show2...");
}
public void haha(){} //去洗头房 对象的特有行为
}
class IPhone4s{
public void call(){
System.out.println("基本语音通话......");
}
}
class IPhone5s extends IPhone4s{
public void call(){
super.call();
System.out.println("添加视频通话......");
}
}
class IPhone6s extends IPhone5s{
public void call(){
super.call();
System.out.println("添加卡通动画......");
}
}
class IPhoneXPlusProMax extends IPhone6s{
//当前对象重写的函数
@Override
public void call(){
System.out.println("虚拟现实+全息投影 通话...");
}
//当前对象的特有函数
public void open5G(){
System.out.println("支持5G网络......");
}
}6.14抽象类
抽象类：
模糊不清的类 不具体的类，当我们在抽取一个父类的时候，发现子类当中的一些共同方法在父类中无法进行具体的实现，并且这些方法只能在子类中具体实现时，父类当中的这些函数就只保留函数声明即可，不必写函数体，那么此时这个函数就是 抽象函数！ 有抽象函数的类 就是抽象类。我们用abstract关键字修饰抽象类。
抽象类一定是父类！并且抽象类不能创建对象。
我们需要注意抽象类里面不能包含private和static关键字，因为我们的抽象类的函数需要被下面的类调用，所以不能私有化。
6.16 多态
多态意思是一个东西可以扮演多种角色。
比如：小红是女孩，他也是人，她也是动物。小红可以是动物，但是他在当动物的时候必须表现出动物应该有的样子，意思就是必有有一个类是冒，一个类是狗，一个类是动物，猫和狗都属于动物，我们将他们继承于动物，在创建他们的时候可以直接Animal a=new Dog();Animal a=new Cat();我们在喂养他们的时候，可以直接传入参数Animal，他会自动判断这个动物是什么来调用相应的函数。
在这里我们需要注意如果子类中没有重写，并且父类中有，就调用父类的，如果子类中有重写，父类也有，就调用子类的，如果子类中没有重写，父类中也没有这个函数，就会报错。
我们用a instanceof pig这个语句来判断a是不是猪，然后进行猪专有的动作。
class DuoTaiDemo02{
public static void main(String[] args){
Dog d=new Dog();
Cat c=new Cat();
Pig p=new Pig();
feed(d);
feed(c);
feed(p);
}
//Animal a=new Dog();
//Animal a=new Cat(); 向上类型转换
public static void feed(Animal a){
a.eat();
//ClassCastException 类型转换异常
//判断对象的本质类型 instanceOf
if(a instanceof Pig){
Pig pp=(Pig)a;
pp.gongBaiCai();
}
}
/*
public static void feed(Pig p){
p.eat();
}
public static void feed(Cat c){
c.eat();
}
public static void feed(Dog d){
d.eat();
}
*/
}
abstract class Animal{
static abstract void eat();
abstract void jiao();
}
class Pig extends Animal{
void eat(){
System.out.println("猪啥都吃......");
}
void jiao(){
System.out.println("猪哼哼哼......");
}
void gongBaiCai(){
System.out.println("猪拱白菜......");
}
}
class Dog extends Animal{
void eat(){
System.out.println("狗吃狗粮......");
}
void jiao(){
System.out.println("狗汪汪汪......");
}
void lookDoor(){
System.out.println("狗看家~......");
}
}
class Cat extends Animal{
void eat(){
System.out.println("猫吃鱼......");
}
void jiao(){
System.out.println("猫喵喵喵......");
}
void catchMouse(){
System.out.println("猫捉老鼠~......");
}
}
6.17 单例模式
设计模式：就是我们的前辈们总结出来的一些编码技巧，它并不是随着Java的诞生而诞生的，它是由Java的广大使用者总结出来的一套编码经验，常见26种
单例模式：使用场景是某一个类只能创建一个对象。比如某一个朝代的皇帝 只能是唯一的
既然只能创建一个对象的话 就得不能让外界去创建对象
1.限制使用new不现实
只能从对象的创建流程中考虑 只要有一个步骤不行 对象就创建不出来
开辟空间分配地址 是由计算机底层决定 我们也控制不了
构造函数执行 只需要将构造函数私有化即可
2.既然外界不能创建对象 我们还得保证对象的创建
所以我们只能在类内部创建对象
Single s=new Single();
能否写成 成员变量的形式？
所以private static
3.内部创建出对象 还得向外界提供
因为private 外界不能直接访问
所以见解 向外界提供一个函数 外界通过调用函数获取对象
扫一扫
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
