java韩顺平学习笔记3

java韩顺平学习笔记3

类变量（静态变量）

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-dzc7LNdU-1690554111773)(C:\Users\luwen\AppData\Roaming\Typora\typora-user-images\image-20230725193637853.png)]

类中定义一个count，所有对象共享

public static int count = 0;

类变量（静态变量）访问方法

• 类名.类变量（推荐）

• 对象名.类变量

类方法（静态方法）

• 调用方法的2种方式：

1. 类名.类方法（static方法才可以这么调用，普通方法无法这么调用）(优点)

2. 对象名.类方法

类方法使用注意事项

类方法中不能使用this和super

**口诀：**静态方法只能访问静态成员（属性，方法）

main语法

args是一个字符串数组，可以接受数组参数

    public static void main(String[] args) {
        for (int i = 0; i <args.length ; i++) {
                    System.out.println("args[" + i + "]" + args[i]);
                }
    }

main动态传值方法

在Program arguments中输出要传入的字符串数组

运行如下

代码块

• 代码块在类中，如果使用构造器，那就会先自动运行代码块，再运行构造器，提高复用性

代码块使用细节

• 要背 （代码块什么时候被调用，类什么时候加载）

• 构造方法、代码块、属性的初始化优先级顺序

• 重点解释1

• 重点解释2

public class Test {
    public static void main(String[] args) {
      new Fish();
    }
}

class Animal {      //父类
    //父类普通代码块
    {
        System.out.println("父类Animal普通代码块被调用");
    }
    
    //父类静态代码块
    static {
        System.out.println("父类Animal静态代码块被调用");
    }
    
	//父类构造器
    public Animal() {
        System.out.println("父类Animal构造器被调用");
    }
}
class Fish extends Animal{      
	//子类静态代码块
    static{
        System.out.println("子类Fish静态代码块被调用-----");

    }
    
    //子类构造器
    public Fish() {
        System.out.println("子类Fish()被调用--------");  //构造器最后
    }
    
		//子类普通代码块
    {
        System.out.println("子类Fish普通代码块被调用-----");
    }

}

输出如下，静态—>普通—>构造器（由super（）会有父类的普通+静态 与子类的静态，判断为父类的静态优先）

单例设计模式（设计模式有23种）

设计模式是什么

单例设计模式介绍

饿汉式（不使用也会创建实例）

public class eHanS {
    private String name;
    private static eHanS eh =new eHanS("德莱文");      //创建新对象，静态变量只会初始化一次
    //私有构造器
    private eHanS(String name) {
        this.name = name;
    }
    //返回一个对象
    public static eHanS getEHanS() {
        return eh;		//静态方法只能调用静态属性
    }
}
public class Test {
    public static void main(String[] args) {
    
    }
}

***代码解读：***由于eh是静态static，所以只会初始化一次eh静态变量

懒汉式（使用的时候才会创建对象，会有线程安全问题）

class lHanS{
    private String name;
    public static lHanS aa;

    private lHanS(String name) {
        this.name=name;
    }
    
    public static lHanS getLHanS(){
        if(aa==null){		//判断是否创建了
            aa=new lHanS("德莱文");
        }
        return aa;
    } 
}

Final关键字（常量）

final使用细节

• final常量一定要赋初值,可以在下面方式之一

class fianlTest{
    public final int age;
    public fianlTest(){
        age =10;			//final常量在构造器中初始化
    }
}

class fianlTest{
    public final int age;
    {
        age = 10;			//final常量在代码块中初始化
    }
}

public final int age = 10;	//在定义时初始化

Demo.i;		//不会导致类加载,类不加载,静态代码块就不会运行

抽象类(abstract修饰符)

抽象类使用细节

抽象模板模式

接口

接口入门代码

• 接口代码

public interface UsbImplements {
    public void start();

    public void end();
}

• 实现接口的类代码

public class Phone implements UsbImplements {
    @Override
    public void start() {
        System.out.println("Phone开始工作");
    }

    @Override
    public void end() {
        System.out.println("Phone结束工作");
    }
}

• 电脑类 调用接口代码

public class Computer {
    public void work(UsbImplements usbImplements){
        usbImplements.start();		//调用传入对象的所实现的接口，不同对象实现不同功能的接口
        usbImplements.end();
    }
}

• 测试代码

public class Test {
    public static void main(String[] args) {
        Phone phone = new Phone();		//创建Phone对象		
        Computer computer = new Computer();		//创建Computer对象
        computer.work(phone);
    }
}

输出结果如下

接口基本介绍

接口的精髓（简洁，方便，不乱）

接口使用细节

（重点6 7 ）

接口VS继承类

继承：本能继承（走，跑，吃喝拉撒）

接口：拓展自身的能力（像鸟一样可以在空中飞，像鱼一样下水活动）

interface Fishable{		//鱼的接口
    void swimming();
}
interface Birdable{		//鸟的接口
    void fly();
}

public class LittleMonkey extends OldMonkey implements Fishable,Birdable{
				//猴子类实现两个接口
    @Override
    public void swimming() {
        System.out.println("猴子通过学习，学会了游泳");
    }

    @Override
    public void fly() {
        System.out.println("猴子通过学习，学会了飞翔");
    }   
}

接口的多态（向上转型）

接口不可以实例化，但是可以指向实现了接口的对象，也可以指向数组（数组里面放的是“指针”，指向对象）

多态传递

interface IA{
    void hi();
}
interface IB extends IA{
	//空
}

public class AA implements IB{
    @Override
    public void hi() {
        System.out.println("你好");
    }
}

类AA在实现接口IB的时候，也必须实现接口IA，因为IB继承了IA