java黑马笔记（2）

多态中：成员方法：编译看左，运行看右（成员变量：编译看左，运行也看左）

访问成员变量的两种方式 ：

a.直接通过对象名称访问成员变量，看等号左边的类是谁，优先用谁,没有则向上找

b.间接通过成员方法访问成员变量，看该方法属于谁（new的是谁的对象），优先用谁，没有则向上找

代码中体现多态性，父类引用指向子类对象 格式:父类名称 对象名 = new 子类名称（）； 或者:接口名称 对象名 = new 实现类名称（）；

//使用多态的写法
Fu obje = new Zi();//new的是子类的,就是子类对象

1.super关键字用来访问父类内容       super.变量    super.方法()    super调用父类的构造方法

this关键字用来访问本类的内容 this.成员变量     在本类的成员方法中，调用本类的另一个成员方法this.方法名 ()       this() 调用本类中的另一个构造方法

super和this两种构造调用不能同时使用

2.继承是单继承    一个类的直接父类只能有一个  即extends  后面只能有一个父类

可以多级继承（父亲，爷爷。。。）  但是接口和接口之间是可以多继承的

3.抽象类和抽象方法，都在public后面加上个abstract           子类还得extends一下

public abstract class Animal {
    //抽象方法，就是加上abstract关键字，然后去掉大括号，直接分号结束
    //抽象方法所在的类必须是抽象类(再class前面写上abstract即可）
    public abstract void eat();
    //普通方法
    public void normalMethod(){ }

public class Cat extends Animal{
    @Override
    public  void eat(){
        System.out.println("cat eat fish");

4.不能直接new一个抽象类的对象，必须用一个子类继承一个抽象父类，且子类必须覆盖重写父类所有的抽象方法（去掉抽象方法中的abstract,然后补上方法体大括号）   创建子类对象进行使用

5.接口就是一种公共的规范标准      要创建实现类的对象才能使用，不能直接创建接口对象       接口是没有构造方法和静态代码块的       接口类也可以作为方法的参数

定义：
public interface InterfaceAbstract {
    public abstract void methodAbs();
    void methodAbs1();//同样是抽象方面p 和 a可以省略不写
}

定义一个实现类，覆盖重写所有的抽象方法
public class InterFaceA implements InterfaceAbstract{
    @Override
    public void methodAbs() {

    }

6.接口中定义的默认方法default会被实现类继承下去的，即创建了实现类对象，就可以调用该默认方法；实现类也可以覆盖重写default方法

//接口定义默认方法，新添加的方法，改成默认方法，可以解决接口升级问题
    public default void methodDefault(){
        System.out.println("这是新添加的默认方法");
    }
//接口类对象直接调用默认方法
impl_1.methodDefault();

7.不能通过接口实现类对象来调用接口中的static方法，通过接口名称.直接调用其中的静态方法

//再接口中定义静态方法
    public static void methodStatic(){
        System.out.println("static method");
    }

8.普通私有方法：解决多个默认方法代码复用问题  静态私有方法：解决多个静态方法代码复用问题

//再接口中定义普通私有方法
 private void methodCommon(){
再接口中定义静态私有方法（多加了个static）
private static void methodStaticCommon(){

9。一旦使用final关键字，即不可改变；接口中只能定义常量（完全大写）且必须赋值

//接口中定义一个常量 p s f 可以省略
    public static final int NUM_ONE = 10;
//直接接口.常量名调用
System.out.println(InterfaceAbstract.NUM_ONE);

10.接口中除了抽象方法，其他默认方法静态方法私有方法都写上方法体

   public abstract void methodAbs();
    void methodAbs1();//同样是抽象方面p 和 a可以省略不写
    //定义默认方法，新添加的方法，改成默认方法，可以解决接口升级问题
    public default void methodDefault(){
        System.out.println("这是新添加的默认方法");
        methodCommon();
    }
    public default void methodDefault1(){
        System.out.println("这是新添加的默认方法1");
        methodCommon();
    }
    //定义静态方法
    public static void methodStatic(){
        System.out.println("static method");
        methodStaticCommon();
    }
    public static void methodStatic1(){
        System.out.println("static method1");
        methodStaticCommon();
    }

11.一个类的直接父类只能有一个，但一个类可以实现多个接口   implements 接口1，接口2

接口中存在多个重名的抽象方法，实现类中只需覆盖重写一次即可；存在多个重名的默认方法，实现类一定要对冲突的默认方法进行覆盖重写

12.父类的方法优先级比接口方法的优先级高（重名的情况）   extends  XXX implements XXX

13,接口与接口之间可以多继承

public interface InterfaceC extends InterfaceAbstract,InterFaceB{

14.继承（extends和implements)是多态的前提

15.多态：a.向上转型：右侧创建一个子类对象，把它当作父类来看待使用 还是遵循最上面的原则

b.向下转型：左侧子类名称 子类对象      = （子类名称）  上方那个对象                这样才能调用子类的方法

Animal cat_1 = new Cat();
        //向下转型
        Cat cat = (Cat) cat_1;

16 instanceof  判断前面的对象能不能当作后面类型的实例  

Animal cat_1 = new Dog();
        //判断前面的对象能不能当作后面类型的实例，返回一个boolean
        if(cat_1 instanceof Cat){
            Cat cat = (Cat) cat_1;
            cat.eat_fish();
        }
        if(cat_1 instanceof Dog){
            Dog dog = (Dog) cat_1;
            dog.watch_home();
        }

17    左父右子，左接口右实现类都是多态

18.final关键字代表最终、不可改变的 可以用来修饰一个类 可以用来修饰一个方法 可以用来修饰一个局部变量 可以用来修饰一个成员变量

a.无任何子类

//final修饰一个类,当前这个类不能有任何子类
//方法块里内容无任何“变化”
public final class Class_one {
}

b.不能被覆盖重写

public final void method(){
        //final修饰一个方法的时候，这个方法就是最终方法，不能被覆盖重写 
    }

c.一次赋值，永不改变，只要保证有唯一一次赋值即可（基本类型是数据不可改变，引用型是地址值不能改变）

//final修饰局部变量，这个变量就不能进行更改
        final int num2 = 200;
        final int num3;
        num3 = 300;

19.

20.内部类：一个类内部包含另一个类         例如：身体和心脏，汽车和发动机

分类：成员内部类，内用外，随意访问；外用内，需要内部类对象        如果出现了重名现象，格式：外部类名称.this.外部类成员变量名
    使用：a.间接方式：在外部类的方法中，使用内部类，然后main                  Body.this.num
            只是调用外部类的方法
          b.直接方式：外部类名称.内部类名称 对象名 = new 外部类名称().new 内部类名称();
            创建了一个内部类的对象

        Body body_1 = new Body();
        //间接使用成员内部类
        body_1.methodBody();
        System.out.println("++++++===");
        //直接使用
        Body.Heart heart_1 = new Body().new Heart();
        heart_1.jump();

      局部内部类,一个类是定义在一个方法内部的，出了这个方法外面就不能用了
       使用：方法内创建内部类的对象，再来方法内调用

21

22.类和接口作为成员变量

//再类中定义一下成员变量
    //类作为成员变量
    private Weapon weapon;//hero weapon
    //接口作为成员变量
    private Skill skill;

//主方法中实现，其中都是创建对象放进去
Hero hero_1 = new Hero();
Weapon weapon_1 = new Weapon("暴风大剑");
hero_1.setWeapon(weapon_1);//塞了一个对象放进去
hero_1.setSkill(new Skillimpl());//塞了一个实现类对象放进去
hero_1.attack();

//Hero类中只需要通过这两个调用相应的方法即可使用   
public void attack(){
        System.out.println(name+","+age +"is using"+weapon.getNick_name());
        System.out.println("释放技能");
        skill.use();
    }