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

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 {@Overridepublic 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");@Overridepublic 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;}@Overridepublic 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;}@Overridepublic 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
}

10.IDEA快捷键大全