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

文章目录

- - 1.static关键字的学习
  - - 1.1为什么需要static关键字
    - 1.2 static总结
  - 2.单例设计模式
  - 3.静态代码块
  - 4.final关键字的使用
  - 5.抽象类和抽象方法
  - - 5.1抽象类的由来
  - 6.接口的使用
  - - 6.1基本概念理解
  - 7.匿名内部类的学习
  - 8.内部类
  - 9.枚举类
  - 9.包装类
  - 10.IDEA快捷键大全

1.static关键字的学习

1.1为什么需要static关键字

当前类的多个实例共享该变量，且此成员变量的值是相同的
方法操作的变量是静态的变量，通常需要将该方法设置为静态方法

1.2 static总结

1.static用来修饰的结构：属性，方法；代码块，内部类；
2.用static修饰的成员变量，叫做类变量
3.整个内存就一份，被类的多个对象所共享
4.静态方法内可以调用静态的属性和其他的静态方法，不能调用非静态结构
5.static修饰的方法内不能调用this和super

class Chinese {
	String name;
	int age;
	static String nation; 
	public static void eat(){}
}

2.单例设计模式

饿汉式

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; // 静态方法内部只能访问静态属性和方法
	}
}

懒汉式

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.静态代码块

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.子类继承父类，必须实现父类的所有抽象方法

语法格式：

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.接口和抽象类的区别：

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

不同

抽象类一定有构造器，接口没有构造器
类和类之间是继承关系，类和接口之间是实现关系，接口和接口之间是多继承关系

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();
}

案例实现：电脑打印机

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通常，我们在创建一个类的实例时，首先需要定义这个类的名字，比如：

class MyComparable implements Comparable {
    @Override
    public int compareTo(Object o) {
        return 0;
    }
}

MyComparable instance = new MyComparable();

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

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

8.内部类

1.啥是内部类？

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

2.内部类的分类

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

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

局部内部类：声明在方法内，构造器内，代码块内的内部类

匿名的局部内部类
非匿名的局部内部类

9.枚举类

1.解释：

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

2.开发中的建议

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

3.案例
3.1jdk5.0之前的定义方法

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使用关键字定义枚举类

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枚举类实现接口

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.如何使用

// 基本转包装类
int num = 10;
Integer i1 = Integer.valueof(num);

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

调用包装类的xxxValue()方法即可
注意：原来使用基本数据类型的位置，改成包装类以后，对于成员变量来说，其默认值变化了
现在基本可以自动装箱和自动拆箱

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

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
}