java学习第十天

抽象类

1.用abstract关键字来修饰一个类时,这个类就叫抽象类

访问修饰符 abstract 类名 {
}
2.用abstract关键字来修饰一个方法时,这个方法就是抽象方法访问修饰符abstract返回类型方法名(参数列表);//没有方法体
3.抽象类的价值更多作用是在于设计,是设计者设计好后，让子类继承并实现抽象类()

4.在框架和设计模式中使用较多

注意事项

1)抽象类不能被实例化
2)抽象类不一定要包含abstract方法。也就是说,抽象类可以没有abstract方法
3)一旦类包含了abstract方法,则这个类必须声明为abstract
4)abstract只能修饰类和方法，不能修饰属性和其它的。

5)抽象类可以有任意成员【抽象类本质还是类】，比如:非抽象方法、构造器、静态属性等等[举例]
6)抽象方法不能有主体，
abst ract void aaa（）;
7)如果一个类继承了抽象类，则它必须实现抽象类的所有抽象方法,
除非它自己也声明为abstract类。

接口

接口就是给出一些没有实现的方法,封装到一起,到某个类要使用的时候,在根据具体情况把这些方法写出来。语法:
interface 接口名 {/属性
//抽象方法)
class 类名 implements 接口 {

自己属性;
自己方法;
必须实现的接口的抽象方法
}
小结:接口是更加抽象的抽象的类，抽象类里的方法可以有方法体，接口里的所有方法都没有方法体【jdk7.0】。接口体现了程序设计的多态和高内聚低偶合的设计思想。
特别说明:Jdk8.0后接口类可以有静态方法，默认方法，也就是说接口中可以有方法的具体实现

注意

1接口不能被实例化
2)接口中所有的方法是 public方法，接口中抽象方法，

可以不用abstract修饰
void aaa();
实际上是abstract void aa();
3)一个普通类实现接口,就必须将该接口的所有方法都实现。

4)抽象类实现接口,可以不用实现接口的方法。

内部类

如果定义类在局部位置(方法中/代码块) :(1) 局部内部类 (2) 匿名内部类

定义在成员位置 (1) 成员内部类 (2) 静态内部类

class Outer{/外部类
class Inner{
//内部类
}
}
class Other{ M/外部其他类

注意

说明:局部内部类是定义在外部类的局部位置，比如方法中，并且有类名。1.可以直接访问外部类的所有成员,包含私有的
2.不能添加访问修饰符,因为它的地位就是一个局部变量。局部变量是不能使用修饰符的。但是可以使用final修饰，因为局部变量也可以使用final
3.作用域:仅仅在定义它的方法或代码块中。
4.局部内部类—访问---->外部类的成员[访问方式:直接访问]5.外部类—访问---->局部内部类的成员
访问方式:创建对象,再访问(注意:必须在作用域内)
记住:(1)局部内部类定义在方法中/代码块
(2)作用域在方法体或者代码块中
(3)本质仍然是一个类

6.外部其他类—不能访问----->局部内部类（因为局部内部类地位是一个局部变量)7.如果外部类和局部内部类的成员重名时，默认遵循就近原则，如果想访问外部类的成员，则可以使用(外部类名.this.成员)去访问【演示】
System.out.println("”外部类的n2=”+外部类名.this.n2);

案例

package inner_class;

public class outer04 {
    public outer04() {
        Inner inner = new Inner();
        inner.a = 10;
        Inner inner1 = new Inner();
        inner1.a = 20;
    }

   public class Inner {
        public int a = 55;

    }

    public static void main(String[] args) {
        outer04 outer04 = new outer04();
        Inner inner = outer04.new Inner();
        System.out.println(inner.a);
    }
}

匿名内部类

(1)本质是类(2)内部类(3)该类没有名字(4)同时还是一个对象
说明:匿名内部类是定义在外部类
的局部位置，比如方法中，并且没有类名1.匿名内部类的基本语法
new 类或接口 (参数列表) {
类体

}

2匿名内部类的语法比较奇特，请大家注意，因为匿名内部类既是一个类的定义,同时它本身也是一个对象，因此从语法上看，它既有定义类的特征，也有创建对象的特征，对前面代码分析可以看出这个特点，因此可以调用匿名内部类方法。

3．可以直接访问外部类的所有成员，包含私有的[案例演示]4、不能添加访问修饰符,因为它的地位就是一个局部变量。[过]
5.作用域:仅仅在定义它的方法或代码块中。[过]
6.匿名内部类—访问---->外部类成员[访问方式:直接访问]

7.外部其他类—不能访问----->匿名内部类（因为匿名内部类地位是一个局部变量)8.如果外部类和匿名内部类的成员重名时，匿名内部类访问的话，默认遵循就近原则,如果想访问外部类的成员，则可以使用(外部类名.this.成员)去访问

案例

package inner_class;

public class outer04 {
    private int n1 = 10;
    public void method() {
        new IA() {
            @Override
            public void cry() {
                System.out.println("猫在叫唤");
            }
        };
    }

    public static void main(String[] args) {
        IA ia = new IA() {
            @Override
            public void cry() {
                System.out.println("老虎在叫唤");
            }
        };
        //ia.cry();
        //System.out.println("ia的运行类型"+ ia.getClass());
       /* Father father = new Father("lisi"){

        };
        System.out.println("运行类型"+ father.getClass());
        Father father1 = new Father("张三");
        System.out.println("运行类型"+ father1.getClass());*/

        /*Father father2 = new Father("wangwu"){
            @Override
            public void test() {
                System.out.println("匿名内部类重写了father的test方法");
            }
        };
        father2.test();*/

        //抽象类的匿名内部类 必须实现abstract方法
        Animal animal = new Animal(){
            @Override
            void eat() {
                System.out.println("动物要吃东西");
            }
        };
        animal.eat();
    }
}

/*class Cat implements IA {
    @Override
    public void cry() {
        System.out.println("猫在叫唤");
    }
}*/

//接口
interface IA {
    public void cry();
}

class Father {
    public Father(String name) {
        System.out.println("接受到name= " + name);
    }
    public void test(){

    }
}

//抽象类
abstract class Animal {
    abstract void eat();
}

将匿名内部类当做实参

package inner_class;
public class outer04 {
    //将匿名内部类作为参数
    public static void main(String[] args) {
        //传统方法
        //Picture picture = new Picture();
        //f1(picture);
        //或者
        //f1(new Picture());

        //将匿名内部类作为实参传入函数
        f1(new IL() {
            @Override
            public void show() {
                System.out.println("一幅画！");
            }
        }
        );
    }
    public static void f1(IL il){
        il.show();
    }
}

interface IL {
    public abstract void show();
}

class Picture implements IL {
    @Override
    public void show() {
        System.out.println("这是一幅画");
    }
}

匿名内部类练习

1.有一个铃声接口Bell，里面有个ring方法。
2.有一个手机类Cellphone，具有闹钟功能
alarmclock，参数是Bell类型(
3.测试手机类的闹钟功能，通过匿名内部类(对
象)作为参数，打印:懒猪起床了
4。再传入另一个匿名内部类(对象)，打印:
小伙伴上课了

package inner_class;

public class outer04 {
    public static void main(String[] args) {
        // 3.测试手机类的闹钟功能，通过匿名内部类(对
//         象)作为参数，打印:懒猪起床了
        Cellphone cellphone = new Cellphone();
        cellphone.alrmclock(new Bell(){
            @Override
            public void ring() {
                System.out.println("懒猪起床了");
            }
        });
//        4。再传入另一个匿名内部类(对象)，打印:
//        小伙伴上课了
        new Cellphone().alrmclock(new Bell(){
            @Override
            public void ring() {
                System.out.println("小伙伴，上课了");
            }
        });
    }

}

/*
1.有一个铃声接口Bell，里面有个ring方法。
        2.有一个手机类Cellphone，具有闹钟功能
        alarmclock，参数是Bell类型(
        3.测试手机类的闹钟功能，通过匿名内部类(对
        象)作为参数，打印:懒猪起床了
        4。再传入另一个匿名内部类(对象)，打印:
        小伙伴上课了*/

//1.有一个铃声接口Bell，里面有个ring方法。
interface Bell {
    public abstract  void ring();
}

//2.有一个手机类Cellphone，具有闹钟功能
//        alarmclock，参数是Bell类型

class Cellphone {


    public void alrmclock(Bell bell){
        bell.ring();
    }
}

编译结果