文章目录
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 abstract4.接口和类之间的关系:实现关系
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
}
10.IDEA快捷键大全