漫漫Java学习路,第十天

package cn.tedu.innerclass;
//本类用于测试内部类的入门案例
public class TestInner1 {
    public static void main(String[] args) {
        /*外部类名.内部类名 对象名 = 外部类对象.内部类对象*/
        Outer.Inner oi = new Outer().new Inner();
        oi.delete();
        System.out.println(oi.sum);
        new Outer().find();

    }
}
//1.定义外部类
class Outer{
    String name;
    private int age;
    public void find(){
        System.out.println("我来组成外壳");
        //sum = 20;
        //delete();
        /*外部类如果想要使用内部类的资源,必须先创建内部类的对象
        * 通过内部类对象来调用内部类的资源*/
        Inner in = new Inner();
        System.out.println(in.sum);
        in.delete();
    }
    //2.定义内部类--外部类的特殊成员
    /*根据内部类位置的不同,分为成员内部类(类里方法外),局部内部类(方法里)*/
    class Inner{
        //3.1定义内部类的成员变量
        int sum = 10;
        //3.2定义内部类的成员方法
        public void delete(){
            System.out.println("我来组成内脏");
            /*结论:内部类可以直接使用外部类的资源,私有成员也可以!*/
            age = 23;
            name = "刘亦菲";
            System.out.println(name+"现年"+age+"岁");
            /*注意此处测试完毕,需要注释掉,否则来回调用
            * 会抛出异常StackOverFlowException栈溢出异常*/
            //find();
        }
    }
}

 

package cn.tedu.innerclass;

public class TestInner2 {
    public static void main(String[] args) {
        //Outer2.Inner2 oi2 = new Outer2().new Inner2();
        //oi2.eat();
        /*如果内部类被private修饰,无法直接在外界创建内部类对象
        * 我们可以创建外部类的对象,间接访问内部类的资源*/
        new Outer2().getInner2est();
    }
}
class Outer2{
    public void getInner2est(){
        Inner2 in = new Inner2();
        in.eat();
    }
    private class Inner2{
        public void eat(){
            System.out.println("麻雀虽小,五脏俱全");
        }
    }
}

package cn.tedu.innerclass;
//本类用于测试成员内部类被static修饰
public class TestInner3 {
    public static void main(String[] args) {
        Other3.Inner3 oi3 = new Other3.Inner3();
        oi3.show();
        /*现象:当内部类被static修饰以后,new Outer3()报错*/
       // new Other3().new Inner3().show();
        new Other3.Inner3().show();
        //调用静态内部类的静态方法--链式加载
        Other3.Inner3.show2();
    }
}
class Other3{
    static class Inner3{
        public void show(){
            System.out.println("哈!看我抓到了什么?");
        }
        public static void show2(){
            System.out.println("是一只象鼻虫的幼虫,鸡肉味,嘎嘣脆");
        }
    }
}

package cn.tedu.innerclass;
//本类用来测试局部内部类
public class TestInner4 {
    public static void main(String[] args) {
        /*如何使用内部类的资源呢?
        * 注意:直接调用外部类的show()是无法除法内部类功能的
        * 需要在外部类中创建内部类对象并且进行调用,才能触发内部类的功能*/
        new Outer4().show();
    }
}
class Outer4{
    public void show(){
        System.out.println("我是外部类的show()方法");
        /*局部内部类的位置在方法里*/
        class Inner4{
            String name;
            int age;
            public void eat(){
                System.out.println("我是局部内部类的eat()方法");
            }
        }
        Inner4 in = new Inner4();
        in.eat();
        System.out.println(in.age);
        System.out.println(in.name);
    }
}

 

package cn.tedu.innerclass;
/*本类用于测试匿名内部类
* 匿名内部类没有名字,通常与匿名对象结合在一起使用*/
public class TestInner5 {
    public static void main(String[] args) {
        new Inter1() {
            @Override
            public void save() {System.out.println("存档");}
            @Override
            public void get() {}
        }.save();
        new Inter2() {
            @Override
            public void drink() {
                System.out.println("一人饮酒醉");
            }
        }.play();
        new Inter3().study();
        new Inter3().powerUp();
    }
}
interface Inter1{
    void save();
    void get();
}
abstract class Inter2{
    public void play(){
        System.out.println("出去耍");
    }
    abstract public void drink();
}
class Inter3{
    public void study(){
        System.out.println("什么是快乐星球");
    }
    public void powerUp(){
        System.out.println("我们会越来越强的!");
    }
}

package cn.tedu.inter;
//本接口用于创建接口测试
/*1.我们通过interface关键字来定义接口*/
public interface Inter {
    /*2.接口中可以定义普通方法吗?-->不可以*/
    //public void fly(){}
    /*3.接口中可以定义抽象方法吗?-->可以,接口中的方法都是抽象方法*/
    public void fly();
    public abstract void eat();
}

package cn.tedu.inter;
//本类作为Inter接口的实现类
/*1.实现类如果想要实现接口定义的功能,需要与接口建立实现关系
* 通过关键字implements来建立实现类 实现 接口的关系*/
/*2.1 方案1:如果实现类与接口建立实现关系以后
* 可以选择不实现接口中的抽象方法,把自己变成一个抽象类*/
//public abstract class InterImpl implements Inter{}
/*2.2 方案2:如果实现类与接口建立实现关系后
* 还可以选择实现节后中的所有抽象方法,把自己变成一个普通子类*/
public class InterImpl implements Inter{
    @Override
    public void fly() {
        System.out.println("芜湖~起飞!");
    }
    @Override
    public void eat() {
        System.out.println("吃火锅");
    }
}

package cn.tedu.inter;
//本类用作就看的测试类
public class InterTest {
    public static void main(String[] args) {
        /*接口可以实例化吗?-->不能*/
        //Inter i = new Inter() ;

        Inter i = new InterImpl();
        i.eat();
        i.fly();

        InterImpl i2 = new InterImpl();
          i2.eat();
          i2.fly();

    }
}

package cn.tedu.inter2;
//接口创建
public interface Person{
    void sleep();
    void eat();
}

package cn.tedu.inter2;

public class Teacher implements Person{
    @Override
    public void sleep() {
        System.out.println("老师在教师食堂吃饭");
    }
    @Override
    public void eat() {
        System.out.println("老师在教师公寓睡觉");
    }
}
class Student implements Person{
    public void sleep(){
        System.out.println("学生在吃大锅饭");
    }
    public void eat(){
        System.out.println("");
    }
}
class Parents implements Person{
    @Override
    public void sleep() {
        System.out.println("在招待所睡大觉");
    }
    @Override
    public void eat() {
        System.out.println("在招待所吃大餐");
    }
}

package cn.tedu.inter2;

public class TestPerson {
    public static void main(String[] args) {
        Student s = new Student();
        s.eat();
        s.sleep();
        Teacher t = new Teacher();
        t.eat();
        t.sleep();
        Parents p = new Parents();
        p.eat();
        p.sleep();
    }
}

package cn.tedu.inter2;
//本类用于测试接口与类之间的复杂关系
public class TestRelation {
}
interface Inter1{
    void save();
    void delete();
}
interface Inter2{
    void update();
    void find();
}
interface Inter3 extends Inter1,Inter2{
    void play();
}
class Inter1Im implements Inter1{
    @Override
    public void save() {
    }
    @Override
    public void delete() {
    }
}
/*1.针对Java的类而言,一个类只能有一个父类:单继承
* 但是一个类可以实现多个接口:多实现*/
class InterImpl2 implements Inter1,Inter2{
    @Override
    public void update() {

    }
    @Override
    public void find() {

    }
    @Override
    public void save() {

    }
    @Override
    public void delete() {

    }
}
class InterImpl3 implements Inter3{
    @Override
    public void save() {

    }
    @Override
    public void delete() {

    }
    @Override
    public void update() {

    }
    @Override
    public void find() {

    }
    @Override
    public void play() {

    }
}

package cn.tedu.inter2;
//本类用于进一步测试接口的使用
public class TestUserInter {
    public static void main(String[] args) {
        UserInterImpl u = new UserInterImpl();
        //测试接口中的静态常量
        System.out.println(UserInter.age);//静态,因为可以被接口名直接调用
        //UserInter.age = 18;//final,因为值不可更改
    }
}
interface UserInter{
    /*接口中是否包含构造方法?-->没有*/
    //public UserInter(){}
    /*接口中是否可以定义成员变量?-->不可以
    * 接口中的是静态常量,实际上的写法是public static final int age = 20;
    * 只不过接口中可以省略不写,会默认拼接,所以写成int age = 20;也可以*/
    public static final int age = 20;
    /*5.接口中抽象方法的定义可以简写,会自动给方法拼接public abstract*/
    void eat();
    public abstract void play();
}
class UserInterImpl implements UserInter{
    public UserInterImpl(){
        /*2.如果一个类没有明确指定它的父类,那么它默认继承顶级父类Object*/
        super();/*3.此处调用的父类的无参构造是Object的无参构造*/
        System.out.println("我是子实现类的无参构造");
    }
    @Override
    public void eat() {
        System.out.println("羊肉串~新疆羊肉串~");
    }
    @Override
    public void play() {
        System.out.println("实现接口中的抽象方法");
    }
}