B站宋红康JAVA基础视频教程个人笔记chapter07（面向对象高级）

aloha_7892024-08-23 3:09

文章目录

1.static关键字的学习

1.1为什么需要static关键字

当前类的多个实例共享该变量，且此成员变量的值是相同的

方法操作的变量是静态的变量，通常需要将该方法设置为静态方法

1.2 static总结

1.static用来修饰的结构：属性，方法；代码块，内部类；

2.用static修饰的成员变量，叫做类变量

3.整个内存就一份，被类的多个对象所共享

4.静态方法内可以调用静态的属性和其他的静态方法，不能调用非静态结构

5.static修饰的方法内不能调用this和super

java 复制代码 
class Chinese {
	String name;
	int age;
	static String nation; 
	public static void eat(){}
}

2.单例设计模式

饿汉式

java 复制代码 
public class BankTest{
	public static void main(String[] args){
		Bank bank1 = Bank.getInstance();
		Bank bank2 = Bank.getInstance();
		sout(bank1 == bank2); // true指向同一个对象
	}
}

class Bank{
	private Bank(){} //构造器私有化
	private static Bank instance = new Bank(); // 作为类的属性出现
	public static Bank getInstance(){
		return Bank; // 静态方法内部只能访问静态属性和方法
	}
}

懒汉式

java 复制代码 
public class GirlFriendTest {
	public static void main(String[] args){
		
	}
}
class GrilFriend{
	// 1.类构造器私有化
	private Girlfriend(){}
	// 2.声明当前类的实例
	private static GirlFriend instance = null;
	// 3.通过get方法获取当前类的实例，如果未创建对象，则在方法内部创建
	public static GirlFriend getInstance(){
		if (instance == null){
			instance = new GirlFriend();
			return instance;
		}
		return instance;  
	}
}

2.1两种模式的对比

特点

饿汉式："立即加载"，随着类的加载，唯一的实例就创建了

懒汉式："延迟加载"，在需要的时候进行创建

优缺点

饿汉式：(优点)写法简单，内存中较早加载，使用较方便，是线程安全。(缺点)：内存中占用时间较长

懒汉式：(缺点)：线程不 安全，(优点)：在需要的时候创建，节省内存空间

3.静态代码块

java 复制代码 
class Person {
	String name;
	int age;
	public Person(){}
	
	// 非静态代码块
	{
	}
	// 静态代码块
	static{
	}
}

具体使用

1.静态代码块

随着类的加载而执行

由于类的加载只会执行一次，进而静态代码块的执行，也会只执行一次

作用：用来初始化类的信息

静态代码块的执行先于非静态代码块
2.非静态代码块
随着对象的创建而执行

每创建当前类的一个实例，就会执行一次非静态代码

作用：初始化对象的信息

4.final关键字的使用

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

2.final修饰的类不能被继承

3.变量修饰后不可以更改。可以在显示赋值，代码块中赋值，构造器中赋值

4.static final修饰的成员变量叫全局常量

5.抽象类和抽象方法

5.1抽象类的由来

1.父类越来越抽象，以至于没有必要创建他的实例对象，这样的类叫做抽象类

2.子类继承父类，必须实现父类的所有抽象方法

语法格式：

java 复制代码 
public abstract class Person{
	public abstract void eat(); //抽象方法，没有方法体
} // 这里定义了abstract，就不能建对象

包含抽象方法的类应该是抽象类

6.接口的使用

6.1基本概念理解

1.接口的本质是一种规范

2.定义接口的关键字：interface

3.接口内部的使用说明：

属性：public static final修饰

方法：jdk8之前，声明未抽象方法，修饰为public abstract

4.接口和类之间的关系：实现关系

5.格式：class A extends SuperA implements B,C{}

6.类可以实现多个接口，弥补了类的单继承的局限性

7.类必须将实现接口中的所有抽象方法都实现，方可实现实例化，否则必须声明为抽象类

8.接口和接口的关系：继承关系，且可以多继承

9.接口的多态性： 接口名 变量名 = new 实现类对象;

10.接口不存在构造器，不能new 调用

11.接口和抽象类的区别：

共性：都可以声明抽象方法，都不能实例化

不同

抽象类一定有构造器，接口没有构造器

类和类之间是继承关系，类和接口之间是实现关系，接口和接口之间是多继承关系

java 复制代码 
public class InterfaceTest{
	public static void main(String[] agrs){
		sout(Flyable.MIN_SPEED);
		
		Bullet b1 = new Bullet();
		b1.fly();
		b1.attack();
	
		// 接口的多态性
		Flyable f1 new Bullet();
		f1.fly();
	
	}
} 
//接口1
interface Flyable { // 接口
	// 1.属性，全局常量
	public static final int MiN_SPEED = 0;
	// 可以省略public static final ，默认也是全局常量，外部无法修改
	int MAX_SPEED = 7900;
	
	// 2.方法：可以省略public abstract声明
	void fly();

}
// 接口2
interface Attackable{
	void attack(); // 省略abstract
}

// 接口实现
// 类必须实现接口的方法
class Bullet implements Flyable, Attackable{
	public void fly(){sout("让子弹飞"};
}



// 测试接口的继承关系
interface AA {
	void method1();
}
interface BB {
	void method2();
}

interface CC extends AA, BB {// 接口可以实现多继承（子接口）
	
}

class DD implements CC{
//重写
	public void method1();
	public void method2();
}

案例实现：电脑打印机

java 复制代码 
public class USBTest{
	public static void  main(String[] args){
		Computer computer = new Computer();
		Printer printer = new Printer();

		computer.transferData(printer);
	}
}

class Computer{
	public transferData(USB usb){ // USB usb = new Printer(); 多态的实现
		Sout("设备连接成功...")
		usb.start();
		sout("数据传输的细节操作");
		usb.stop();
	}
}

//外部设备(一般电脑下载驱动就是这个)
class Printer implements USB{
	public abstract void start(){
		sout("打印机开始工作");
	};
	public abstract void stop(){
		sout("打印机结束工作")
	};
}

interface USB{
	// 声明常量：
	// 方法
	public abstract void start();
	public abstract void stop();
}

7.匿名内部类的学习

7.1通常，我们在创建一个类的实例时，首先需要定义这个类的名字，比如：

java 复制代码 
class MyComparable implements Comparable {
    @Override
    public int compareTo(Object o) {
        return 0;
    }
}

MyComparable instance = new MyComparable();

匿名内部类则是省略了类名，直接在创建类的实例时定义了类的行为。换句话说，匿名内部类就是一个没有名字的类，我们在定义它的同时就创建了它的实例

7.2匿名内部类的语法格式如以下

java 复制代码 
new 接口名或父类名() {
    // 类的实现,原本你打算在类里面写啥东西就写在这里就行了
};

8.内部类

1.啥是内部类？

将一个类A定义在另一个类B里面，里面那个类就称为"内部类"，类B则称为"外部类"

2.内部类的分类

成员内部类:直接声明在外部类里面

使用static修饰的，静态的成员内部类

不使用static修饰的，非静态的成员内部类
局部内部类：声明在方法内，构造器内，代码块内的内部类
匿名的局部内部类

非匿名的局部内部类

9.枚举类

1.解释：

枚举类本质上也是一种类，只不过这个类的对象是有限的，固定的几个，不能让用户随意创建

2.开发中的建议

开发中，如果针对某个类，其实例是确定个数的。则推荐将此类声明为枚举类

3.案例

3.1jdk5.0之前的定义方法

java 复制代码 
public class SeasonTest {
    public static void main(String[] args) {
        System.out.println(Season.spring); // 默认调用类的toString方法
    }
}

class Season{
    private final String seasonName; // 只能获取不能修改
    private final String seasonDesc; // final修饰的变量必须被初始化，且初始化后不能修改

    // 1.私有化的构造器
    private Season(String seasonName, String seasonDesc) {
        this.seasonName = seasonName;
        this.seasonDesc = seasonDesc;
    }


    public String getSeasonName() {
        return seasonName;
    }

    public String getSeasonDesc() {
        return seasonDesc;
    }

    // 创建对象
    public static final Season spring = new Season("Spring", "Spring");
    public static final Season summer = new Season("Summer", "Summer");
    public static final Season autumn = new Season("Autumn", "Autumn");
    public static final Season winter = new Season("Winter", "Winter");

    @Override
    public String toString() {
        return "Season{" +
                "seasonName='" + seasonName + '\'' +
                ", seasonDesc='" + seasonDesc + '\'' +
                '}';
    }
}

3.2.jdk5.0使用关键字定义枚举类

java 复制代码 
public class SeasonTest1 {
    public static void main(String[] args) {
        System.out.println(Season1.SPRING);
    }
}

enum Season1{

    // 必须再枚举类的开头声明多个对象，对象之间使用逗号隔开
    SPRING("spring", "spring"),
    SUMMER("summer", "summer"),
    AUTUMN("autumn", "autumn"),
    WINTER("winter", "winter");


    private final String seasonName;
    private final String SeasonDesc;

    private Season1(String seasonName, String SeasonDesc){
        this.seasonName = seasonName;
        this.SeasonDesc = SeasonDesc;
    }

    public String getSeasonName() {
        return seasonName;
    }

    public String getSeasonDesc() {
        return SeasonDesc;
    }

    @Override
    public String toString() {
        return "Season1{" +
                "seasonName='" + seasonName + '\'' +
                ", SeasonDesc='" + SeasonDesc + '\'' +
                '}';
    }
}

使用enum关键字定义的枚举类，默认其父类是java.lang,Enum类

属性是private ,final修饰

构造器是private修饰

3.3枚举类实现接口

java 复制代码 
public class SeasonTest2 {
    public static void main(String[] args) {
        Season2[] values = Season2.values();
        for(int i = 0; i<values.length; i++) {
            values[i].info(); // values[i]是得到的每个对象的实例
        }
    }
}

interface info1{
    void info();
}

enum Season2 implements info1{
    // 枚举类实现接口中的方法
    SPRING("spring", "spring"){
        public void info() {
            System.out.println("春天再哪里");
        }
    },
    SUMMER("summer", "summer"){
        public void info() {
            System.out.println("夏天再哪里");
        }
    },
    AUTUMN("autumn", "autumn"){

        public void info() {
            System.out.println("秋天再哪里");
        }
    },
    WINTER("winter", "winter"){
        public void info() {
            System.out.println("冬天再哪里");
        }
    };

    private final String seasonName;
    private final String seasonDesc;

    private Season2(String seasonName, String seasonDesc){
        this.seasonName = seasonName;
        this.seasonDesc = seasonDesc;
    }

    public String getSeasonName() {
        return seasonName;
    }

    public String getSeasonDesc() {
        return seasonDesc;
    }

    @Override
    public String toString() {
        return "Season2{" +
                "seasonName='" + seasonName + '\'' +
                ", seasonDesc='" + seasonDesc + '\'' +
                '}';
    }
}

9.包装类

1.有哪些包装类

2.为什么要使用包装类

为了使得基本数据类型的变量具备引用数据类型的相关特征(比如：封装继承多态)

3.如何使用

java 复制代码 
// 基本转包装类
int num = 10;
Integer i1 = Integer.valueof(num);

// 包装类转基本
Integer i1 = Integer.valueof(20);
int num1 = i1.intValue();

调用包装类的xxxValue()方法即可

注意：原来使用基本数据类型的位置，改成包装类以后，对于成员变量来说，其默认值变化了

现在基本可以自动装箱和自动拆箱

4.包装类/基本数据类型和String之间的转换

java 复制代码 
public class Test{
	// 基本转String 
	int i1 = 10;
	String str1 = String.valueOf(i1);
	sout(strl); // "10"
	
	// String转基本
	String s1 = "123";
	int i1 = Interger.parseInt(s1);
	sout(i1) // 123
}

10.IDEA快捷键大全




相关推荐
J不A秃V头A2 分钟前
Python爬虫：获取国家货币编码、货币名称
开发语言·爬虫·python
憨子周1 小时前
2M的带宽怎么怎么设置tcp滑动窗口以及连接池
java·网络·网络协议·tcp/ip
霖雨3 小时前
使用Visual Studio Code 快速新建Net项目
java·ide·windows·vscode·编辑器
SRY122404193 小时前
javaSE面试题
java·开发语言·面试
Fiercezm3 小时前
JUC学习
java
2401_858286113 小时前
L7.【LeetCode笔记】相交链表
笔记·leetcode·链表
无尽的大道3 小时前
Java 泛型详解：参数化类型的强大之处
java·开发语言
ZIM学编程3 小时前
Java基础Day-Sixteen
java·开发语言·windows
我不是星海3 小时前
1.集合体系补充（1）
java·数据结构
放逐者-保持本心，方可放逐3 小时前
react 组件应用
开发语言·前端·javascript·react.js·前端框架
热门推荐
01聊聊 Python 中的同步原语，为什么有了 GIL 还需要同步原语02【HarmonyOS】HUAWEI DevEco Studio 下载地址汇总03Windows10安装PCL1.14.0及点云配准04C++——超强级病毒代码05全面解析：构建基于深度学习的安全帽检测系统（UI界面+YOLO代码+数据集）06组基轨迹建模 GBTM的介绍与实现（Stata 或 R）07硬件预取之空间预取08Ubuntu 20.04使用Livox mid 360 测试 FAST_LIO09Coze扣子平台完整体验和实践（附国内和国际版对比）10【SCS-CN】SCS-CN模型中CN值的确定