JAVA随笔 03

权限修饰符

修饰符	同一个类中	同一个包中 子类无关类	不同包的子类	不同包的 无关类
private	√
默认	√	√
protected	√	√	√
public	√	√	√	√

继承概述

继承的格式

格式: public class 子类名 extends 父类名{}
范例: public class Zi extends Fu{}
Fu: 是父类, 也被称为基类, 超类
Zi: 是子类, 也被称为派生类

继承中子类的特点: 子类可以有父类的内容, 同时新增自己独特的内容

继承的好处和弊端

继承的好处: 提高了代码的复用性(多个类相同的成员可以放到同一个类中); 提高了代码的维护性(如果方法的代码需要修改, 修改一处即可)

继承的弊端: 继承让类和类之间产生了关系, 类的耦合性增强了, 当父类发生变化时, 子类实现也不得不跟着变化, 削弱了子类的独立性.

什么时候使用继承?

继承关系的体现: is a;比如猫是动物, 苹果是水果.这种时候就可以使用继承.

继承中变量的访问顺序

在子类方法中访问一个变量, 会按照以下顺序寻找:

子类局部范围--> 子类成员范围--> 父类成员范围

继承中成员方法的访问顺序

通过子类对象访问一个方法

子类成员范围--> 父类成员范围

继承中构造方法的访问特点

子类中所有的构造方法默认都会访问父类中无参的构造方法

因为子类会继承父类中的数据, 可能还会使用父类的数据. 所以子类初始化之前, 一定会完成父类数据的初始化.

每一个子类构造方法的都隐藏着一句 super()

继承中方法重写的注意事项

私有方法不能被重写(因为子类无法继承到父类的私有方法)

子类方法重写父类方法,访问权限应该大于等于父类方法(public > 默认 > private)

抽象类的特点

抽象类和抽象方法必须使用abstract关键词修饰

public abstract class 类名{}
public abstract void eat();

抽象类中不一定有抽象方法, 有抽象方法的类一定是抽象类.

抽象类不能直接实例化, 只能参照多态的方式, 通过子类对象实例化, 这叫抽象类多态.

抽象类的子类: 要么重写抽象类中的所有抽象方法, 要么本身是抽象类.

抽象类的成员特点

成员变量: 可以是变量, 也可以是常量(final修饰)

构造方法: 有构造方法, 但是不能被实例化, 用于子类访问父类数据的初始化

成员方法: 可以有抽象方法, 限定子类必须完成某些动作. 也可以有非抽象方法, 提高代码的复用性(用继承来实现)

接口

接口的特点

接口用关键字interface修饰:

        public interface 接口名{}

类实现接口用implements表示

        public class 类名 implements 接口名{}

接口不能直接实例化

        参照多态的方式, 通过实现类对象实例化, 这叫接口多态.

多态的形式: 具体类多态(几乎不使用), 抽象类多态, 接口多态.

多态的前提: 有继承或者实现关系; 有方法重写; 有父(类/接口)引用指向(子/实现)类对象

 接口的实现类: 和抽象类的实现类相似, 要么重写接口中的所有抽象方法, 要么本身是抽象类.

接口的成员特点

成员变量: 只能是常量, 默认带有修饰符: public static final

构造方法: 接口没有构造方法, 因为接口主要是对行为进行抽象的, 是没有具体存在的.

一个类如果没有父类, 默认继承自Object类. Object类是所有类的根类.

成员方法: 只能是抽象方法, 默认带有修饰符: public abstract

抽象类和接口的区别

成员区别:

抽象类: 包含变量, 常量, 构造方法, 抽象方法, 非抽象方法

接口: 包含常量, 抽象方法

关系区别:

类与类: 继承, 单继承

类与接口: 实现,可以单实现, 也可以多实现

接口与接口: 继承,单继承,多继承

设计理念区别:

抽象类: 对类抽象, 包括属性, 行为

接口: 对行为抽象, 主要是行为

匿名内部类

(匿名内部类也是局部内部类的一种)

前提: 存在一个类或者接口, 这里的类可以是具体类也可以 是抽象类

格式:
new 类名或者接口名(){
    重写方法;
}

范例:
new Inter(){
    public void show(){
    }
}

本质: 是一个继承了该类或者实现了该接口的子类匿名对象

在开发中的用法:

当你有只使用一次的具体类对象时, 可以使用匿名内部类来替代创建具体类.

/*
    跳高接口
*/
public interface Jumpping{
    void jump();
}


/*
    接口操作类, 里面有一个方法, 方法的参数是接口名
*/
public class JumppingOperator{

    public void method(Jumpping j){
        j.jump();
    }
}


/*
    具体的实现类
*/
public class Cat implements Jumpping{
    @Override
    public void jump(){
        System.out.private("猫可以跳高了")
    }
}


/*
    测试类
*/
public class JumppingDemo{
    public static void main(String[] args){
        JumppingOperator jo = new JumppingOperator();
        Jumpping j = new Cat();
        jo.method(j);
    }
}

使用匿名内部类可以替代掉具体的类实现如Cat... 下面为更新后的代码:

/*
    跳高接口
*/
public interface Jumpping{
    void jump();
}


/*
    接口操作类, 里面有一个方法, 方法的参数是接口名
*/
public class JumppingOperator{

    public void method(Jumpping j){
        j.jump();
    }
}


/*
    测试类
*/
public class JumppingDemo{
    public static void main(String[] args){
        JumppingOperator jo = new JumppingOperator();
        jo.method(new Jumpping(){
            @Override
            public void jump(){
                System.out.println("猫可以跳高了");
            }
        });
    }
}