this,super代码块,内部类

什么情况下使用继承

1.经过需求分析,发现两个无关的类存在共同的代码,可以考虑继承

2.在现实生活中,两个类存在明显的is A关系,可以用继承关系

多态的好处:降低耦合性/把实现类对象赋给接口类变量,屏蔽了不同实现类之间的差异,从而做到通用编程

面向接口编程:重心不在于持有数据,从而不依赖于某种特定类型的对象,进而对两个模块功能进行解耦

两个模块/组件的解耦,降低耦合度

模块和模块之间的衔接都是用接口,架构师的眼中只有接口,我们称之为面向接口

this关键字

内存图

this关键字用法

• 调用成员变量,解决二义性.表示当前对象本身,一般用于类的内部,内部存在一个地址

• 调用一个方法:调用其他的实例方法(非static修饰的方法),this可以省略,但是不建议省略

• 调用本类的其它构造方法(无参构造给反射用)/语法this(…),必须写到有效代码的第一行

public class Dog {
    private String sn;
    private String name;
    private int age;

    public String getSn() {
        return sn;
    }

    public void setSn(String sn) {
        this.sn = sn;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }
	//调用本类其它构造方法
    public Dog(String sn, String name, int age) {
        this(sn, name);//必须写在第一行
        this.age = age;
    }

    public Dog(String sn, String name) {
        this.sn = sn;//实例对象本身
        this.name = name;
    }

    public Dog() {
    }
    public void shouInfo(){
        System.out.println("this.name = " + this.name);
        System.out.println("this.sn = " + this.sn);
        System.out.println("this.age = " + this.age);
    }
    public void sayHi(){
        System.out.println("你好呀");
        //调用本类的实例方法
        this.shouInfo();
    }
}

super关键字

在子类方法中 ,调用父类被子类覆盖的方法

super只是一个关键字,内部没有引用(地址)

super关键字用法:

• super访问父类非私有的字段(不符合javabean规范)

• super访问父类非私有的实例方法

• super可以访问父类的构造方法,语法super(…)必须写在有效代码的第一行

  • 省略不写的话,默认是调用子类的,如果子类没有重写父类方法,才是父类的
  • 如果子类构造方法(不管有没有参数)只要没有显式的调用父类的构造方法,jvm会默认的调用父类的无参构造

public class Dog extends Pet{
    private String type;

    public String getType() {
        return type;
    }

    public void setType(String type) {
        this.type = type;
    }

    public Dog() {
    }

    public Dog(String nick, int health, int love, String type) {
        super(nick, health, love);
        this.type = type;
    }

    @Override
    public void showInfo() {
        super.showInfo();
        System.out.println("this.type = " + this.type);
    }
}

static修饰符

实例变量,实例方法归实例所有

可以修饰变量构成静态变量,修饰方法构成静态方法

静态变量和静态方法都归类所有,称为类的静态成员

在类中,用static关键字修饰的成员变量叫做静态变量,归类所有,也叫作类变量,类的所有实例/对象都可以访问,被类的所有实例/对象共享

static修饰的成员变量放在方法区

语法:

static 数据类型 变量名 [= 初始值]

访问语法:

对象/实例.静态变量

类名.静态变量(推荐写法)

//实例变量:归实例所有   
	private String brand;
    private String type;
//静态变量
    static int count = 0;
//静态方法
	    public static int getCount(){
        //静态方法中可以调用其他的静态方法
        Car.test();
        return Car.count;
    }

    public static void test(){
        System.out.println("1111");
    }
	
    public String getBrand() {
        return brand;
    }

    public void setBrand(String brand) {
        this.brand = brand;
    }

    public String getType() {
        return type;
    }

    public void setType(String type) {
        this.type = type;
    }

    public Car(String brand, String type) {
        this.brand = brand;
        this.type = type;
        Car.count++;
        //this.count++(也可以,但是不推荐)
    }

    public Car() {
        Car.count++;
    }

静态方法特性:

静态方法可以访问静态变量和该类的其他静态方法

不能在静态方法中访问实例成员;实例方法中可以访问静态变量和静态方法

final修饰符

可以修饰类,方法,成员变量,局部变量

final修饰的类不能够被继承

final修饰的方法不能够被重写

final修饰的局部变量称为常量,只能被赋值一次,不能被重新赋值final还可以修饰引用数据类型(常引用),引用地址不能更改,但是可以改堆中的内容

常量命名都要大写,单词之间用下划线分割

代码块

{}标记的代码叫做代码块

按位置说:普通代码块,构造代码块,静态代码块,同步代码块

普通代码块

访问一个变量时,先在当前作用域查找,找不到的话向上层作用域查找,找不到的话就继续向上查找,形成一个

构造代码块

在类的内部,方法之外

在构造方法之前执行

静态代码块

被static修饰的代码块

位于类的内部,方法的外部

只执行一次,在构造代码块和构造方法之前执行

静态代码块随字节码加载的时候执行,所以只执行一次(当需要类被加载进虚拟机的时候就去执行的操作就放在这里)

private String name;
    private int age;

    static{
        System.out.println("静态代码块");
    }
    {
        System.out.println("构造代码块");
    }
    public Person() {
        System.out.println("无参构造器");
    }

内部类

一个文件中可以定义多个类,但只能有一个public类,且文件名和public类的名字一致,类和类之间是平行关系,

类和类之间的包含关系,内部类作为外部类的一个成员而存在

如何创建内部类的对象:

1.创建外部类的对象

Outer outer = new Outer();

2.创建内部类对象

Outer.Inner inner = outer.new Inner();

3.调用内部类的方法

inner.showInfo();

成员内部类可以直接访问外部类的私有成员

静态内部类

1.创建对象

Outer.Inner inner = new Outer.Inner();

静态内部类可以直接访问外部类的静态私有成员

方法内部类

类存在于方法中时,构成方法内部类,只能在方法中创建对象

只可以读取方法中的局部变量,但是不能够更改

没有名字的对象,叫做匿名对象

匿名内部类

一个类只使用一次,可以声明为匿名内部类

匿名内部类必须有实现存在

枚举