JavaSE学习总结第10天_面向对象5

 

10.01 运动员和教练案例分析

教练和运动员案例:运动员分乒乓球运动员和篮球运动员，教练分乒乓球教练和篮球教练。为了出国交流，跟乒乓球相关的人员都需要学习英语。

分析:

10.02 运动员和教练案例实现

//定义一个说英语的接口
interface SpeakEnglish 
{
    //说英语
    public abstract void speak();
}

//定义人的抽象类
abstract class Person 
{
    private String name;
    private int age;
    
    public Person() {}
    
    public Person(String name,int age) 
    {
        this.name = name;
        this.age = age;
    }
    
    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 void sleep() 
    {
        System.out.println("人都是要睡觉的");
    }
    
    //吃饭
    public abstract void eat();
}

//定义运动员抽象类
abstract class Player extends Person 
{
    public Player() {}
    
    public Player(String name,int age) 
    {
        super(name,age);
    }
    
    //学习
    public abstract void study();
}

//定义教练抽象类
abstract class Coach extends Person 
{
    public Coach() {}
    
    public Coach(String name,int age) 
    {
        super(name,age);
    }
    
    //教学
    public abstract void teach();
}

//定义乒乓球运动员具体类
class PingPangPlayer extends Player implements SpeakEnglish 
{
    public PingPangPlayer(){}
    
    public PingPangPlayer(String name,int age) 
    {
        super(name,age);
    }
    
    //吃
    public void eat() 
    {
        System.out.println("乒乓球运动员吃大白菜，喝小米粥");
    }
    
    //学习
    public void study() 
    {
        System.out.println("乒乓球运动员学习如何发球和接球");
    }
    
    //说英语
    public void speak() 
    {
        System.out.println("乒乓球运动员说英语");
    }
}

//定义篮球运动员具体类
class BasketballPlayer extends Player 
{
    public BasketballPlayer(){}
    
    public BasketballPlayer(String name,int age) 
    {
        super(name,age);
    }
    
    //吃
    public void eat() 
    {
        System.out.println("篮球运动员吃牛肉，喝牛奶");
    }
    
    //学习
    public void study() 
    {
        System.out.println("篮球运动员学习如何运球和投篮");
    }
}

//定义乒乓球教练具体类
class PingPangCoach extends Coach implements SpeakEnglish 
{
    public PingPangCoach(){}
    
    public PingPangCoach(String name,int age) 
    {
        super(name,age);
    }
    
    //吃
    public void eat() 
    {
        System.out.println("乒乓球教练吃小白菜，喝大米粥");
    }
    
    //教
    public void teach() 
    {
        System.out.println("乒乓球教练教如何发球和接球");
    }
    
    //说英语
    public void speak() 
    {
        System.out.println("乒乓球教练说英语");
    }
}

//定义篮球教练具体类
class BasketballCoach extends Coach 
{
    public BasketballCoach(){}
    
    public BasketballCoach(String name,int age) 
    {
        super(name,age);
    }
    
    //吃
    public void eat() 
    {
        System.out.println("篮球教练吃羊肉，喝羊奶");
    }
    
    //教
    public void teach() 
    {
        System.out.println("篮球教练教如何运球和投篮");
    }
}

10.03 运动员和教练案例测试

//定义一个说英语的接口
interface SpeakEnglish 
{
    //说英语
    public abstract void speak();
}

//定义人的抽象类
abstract class Person 
{
    private String name;
    private int age;
    
    public Person() {}
    
    public Person(String name,int age) 
    {
        this.name = name;
        this.age = age;
    }
    
    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 void sleep() 
    {
        System.out.println("人都是要睡觉的");
    }
    
    //吃饭
    public abstract void eat();
}

//定义运动员抽象类
abstract class Player extends Person 
{
    public Player() {}
    
    public Player(String name,int age) 
    {
        super(name,age);
    }
    
    //学习
    public abstract void study();
}

//定义教练抽象类
abstract class Coach extends Person 
{
    public Coach() {}
    
    public Coach(String name,int age) 
    {
        super(name,age);
    }
    
    //教学
    public abstract void teach();
}

//定义乒乓球运动员具体类
class PingPangPlayer extends Player implements SpeakEnglish 
{
    public PingPangPlayer(){}
    
    public PingPangPlayer(String name,int age) 
    {
        super(name,age);
    }
    
    //吃
    public void eat() 
    {
        System.out.println("乒乓球运动员吃大白菜，喝小米粥");
    }
    
    //学习
    public void study() 
    {
        System.out.println("乒乓球运动员学习如何发球和接球");
    }
    
    //说英语
    public void speak() 
    {
        System.out.println("乒乓球运动员说英语");
    }
}

//定义篮球运动员具体类
class BasketballPlayer extends Player 
{
    public BasketballPlayer(){}
    
    public BasketballPlayer(String name,int age) 
    {
        super(name,age);
    }
    
    //吃
    public void eat() 
    {
        System.out.println("篮球运动员吃牛肉，喝牛奶");
    }
    
    //学习
    public void study() 
    {
        System.out.println("篮球运动员学习如何运球和投篮");
    }
}

//定义乒乓球教练具体类
class PingPangCoach extends Coach implements SpeakEnglish 
{
    public PingPangCoach(){}
    
    public PingPangCoach(String name,int age) 
    {
        super(name,age);
    }
    
    //吃
    public void eat() 
    {
        System.out.println("乒乓球教练吃小白菜，喝大米粥");
    }
    
    //教
    public void teach() 
    {
        System.out.println("乒乓球教练教如何发球和接球");
    }
    
    //说英语
    public void speak() 
    {
        System.out.println("乒乓球教练说英语");
    }
}

//定义篮球教练具体类
class BasketballCoach extends Coach 
{
    public BasketballCoach(){}
    
    public BasketballCoach(String name,int age) 
    {
        super(name,age);
    }
    
    //吃
    public void eat() 
    {
        System.out.println("篮球教练吃羊肉，喝羊奶");
    }
    
    //教
    public void teach() 
    {
        System.out.println("篮球教练教如何运球和投篮");
    }
}
class Demo
{
    public static void main(String[] args)
    {
        //测试运动员(乒乓球运动员和篮球运动员)
        //乒乓球运动员
        PingPangPlayer ppp = new PingPangPlayer();
        ppp.setName("王浩");
        ppp.setAge(33);
        System.out.println(ppp.getName()+"---"+ppp.getAge());
        ppp.eat();
        ppp.sleep();
        ppp.study();
        ppp.speak();
        System.out.println("----------------");
        
        //篮球运动员
        BasketballPlayer bp = new BasketballPlayer();
        bp.setName("姚明");
        bp.setAge(34);
        System.out.println(bp.getName()+"---"+bp.getAge());
        bp.eat();
        bp.sleep();
        bp.study();
        //bp.speak(); //没有该方法
    }
}

运行结果:

王浩---33
乒乓球运动员吃大白菜，喝小米粥
人都是要睡觉的
乒乓球运动员学习如何发球和接球
乒乓球运动员说英语
----------------
姚明---34
篮球运动员吃牛肉，喝牛奶
人都是要睡觉的
篮球运动员学习如何运球和投篮

10.04 类名作为形式参数

形式参数和返回值问题

形式参数:基本类型、引用类型(类、抽象类、接口)

返回值类型:基本类型、引用类型(类、抽象类、接口)

例:

class Student
{
    public void study()
    {
        System.out.println("好好学习");
    }
}
class StudentTest
{
    //形式参数是一个类
    public void method(Student s)
    {
        s.study();
    }
}
class Demo
{
    public static void main(String[] args)
    {
        StudentTest st = new StudentTest();
        Student s = new Student();
//需要的是该类的对象
        st.method(s);
    }
}

运行结果:

好好学习

10.05 抽象类名作为形式参数

例:

abstract class Person
{
    public abstract void study();
}

class Student extends Person
{
    public void study()
    {
        System.out.println("好好学习");
    }
}
class PersonTest
{
    //形式参数是一个抽象类
    public void method(Person p)
    {
        p.study();
    }
}
class Demo
{
    public static void main(String[] args)
    {
        PersonTest pt = new PersonTest();
        Person p = new Student();
        //需要该抽象类的子类对象
        pt.method(p);
    }
}

运行结果:

好好学习

10.06 接口名作为形式参数

例:

interface Love
{
    public abstract void love();
}
class Teacher implements Love
{
    public void love()
    {
        System.out.println("老师爱学生");
    }
}
class LoveTest
{
    //形式参数是一个接口
    public void method(Love l)
    {
        l.love();
    }
}
class Demo
{
    public static void main(String[] args)
    {
        LoveTest lt = new LoveTest();
        Love l = new Teacher();
        //需要该接口的实现类对象
        lt.method(l);
    }
}

运行结果:

老师爱学生

10.07 类名作为返回值类型

例:

class Student
{
    public void study()
    {
        System.out.println("好好学习");
    }
}
class StudentTest
{
    //返回值是一个类
    public Student getStudent()
    {
        //真实返回的是该类的对象
        return new Student();
    }
}
class Demo
{
    public static void main(String[] args)
    {
        StudentTest st = new StudentTest();
        Student s = st.getStudent();
        s.study();
    }
}

10.08 抽象类名作为返回值类型

例:

abstract class Person
{
    public abstract void study();
}
class Student extends Person
{
    public void study()
    {
        System.out.println("好好学习");
    }
}
class PersonTest
{
    //返回值是一个抽象类
    public Person getPerson()
    {
        //真实返回的是抽象类的子类对象
        return new Student();
    }
}
class Demo
{
    public static void main(String[] args)
    {
        PersonTest pt = new PersonTest();
        Person p = pt.getPerson();
        p.study();
    }
}

10.09 接口名作为返回值类型

例:

interface Love
{
    public abstract void love();
}
class Teacher implements Love
{
    public void love()
    {
        System.out.println("老师爱学生");
    }
}
class LoveTest
{
    //返回值是一个接口
    public Love getLove()
    {
        //真实返回的是该接口的实现类对象
        return new Teacher();
    }
}
class Demo
{
    public static void main(String[] args)
    {
        LoveTest lt = new LoveTest();
        Love l = lt.getLove();
        l.love();
    }
}

10.10 链式编程

例:

class Student
{
    public void study()
    {
        System.out.println("好好学习");
    }
}
class StudentTest
{
    public Student getStudent()
    {
        return new Student();
    }
}
class Demo
{
    public static void main(String[] args)
    {
        //链式编程，每次调用方法完毕后返回的是一个对象
        new StudentTest().getStudent().study();
    }
}

10.11 package关键字的概述及作用

包的概述:其实就是文件夹

作用:对类进行分类管理

包的划分:

例:学生的增加，删除，修改，查询和老师的增加，删除，修改，查询

基本的划分:

按照功能分

cn.itcast.add(AddStudent,AddTeacher)

cn.itcast.delete(DeleteStudent,DeleteTeacher)

cn.itcast.update(UpdateStudent,UpdateTeacher)

cn.itcast.find(FindStudent,FindTeacher)       

按照模块分

cn.itcast.teacher(AddTeacher,DeleteTeacher,UpdateTeacher,FindTeacher)

cn.itcast.student(AddStudent,DeleteStudent,UpdateStudent,FindStudent)           

10.12 包的定义及注意事项

定义包的格式:package 包名; 多级包用.分开即可

注意事项:

1.package语句必须是程序的第一条可执行的代码

2.package语句在一个java文件中只能有一个

3.如果没有package，默认表示无包名

10.13 带包的类编译和运行

手动式

1:javac编译当前类文件

2:手动建立包对应的文件夹

3:把1步骤的class文件放到2步骤的最终文件夹下

4:通过java命令执行。

注意:需要带包名称执行

例:

package cn.itcast;
class Demo
{
    public static void main(String[] args)
    {
        System.out.println("hello world");
    }
}

运行:

自动式

1:javac编译的时候带上-d即可

例:javac -d . HelloWorld.java (-d后面跟的是目录, .表示当前目录)

2:通过java命令执行。需要带包名称执行。

10.14 不同包下类之间的访问

例:

定义两个类:Demo,Test。

Demo:测试方法(main)

Test:求和方法(sum)

运行步骤如下:

 

10.15 import关键字的概述和使用

导包概述:不同包下的类之间的访问，每次使用不同包下的类的时候，都需要加包的全路径。比较麻烦。这个时候，java就提供了导包的功能。

导包格式:import 包名;

注意:这种方式导入是到类的名称。虽然可以最后写*，但是不建议。使用哪个类就导入哪个类。

例:

面试题:package,import,class有没有顺序关系?

有，package>import>class

package:只能有一个

import:可以有多个

class:可以有多个，建议只写一个

10.16 四种权限修饰符

10.17 类及其组成所使用的常见修饰符

权限修饰符:public、protected、默认的、private

状态修饰符:static、final

抽象修饰符:abstract

 

1.类:默认，public、final、abstract。其中使用public居多

2.成员变量:四种权限修饰符均可，final、static。其中使用private居多

3.构造方法:四种权限修饰符均可，其他不可以。其中使用public居多

4.成员方法:四种权限修饰符均可，fianl、static、abstract。其中使用public居多

 

10.18 内部类概述和访问特点

把类定义在其他类的内部，这个类就被称为内部类。

例:在类A中定义了一个类B，类B就是内部类。

内部类的访问特点:

内部类可以直接访问外部类的成员，包括私有。

外部类要访问内部类的成员，必须创建对象。

例:

class Outer
{
    private int num = 10;
//内部类
    class Inner
    {
        public void show()
        {
            //内部类可以直接访问外部类的成员，包括私有
            System.out.println("show run..."+num);
        }
    }
    public void method()
    {
        //外部类要访问内部类的方法必须创建内部类的对象
        Inner in = new Inner();
        in.show();
    }
}

10.19 内部类分类及成员内部类的使用

按照内部类在类中定义的位置不同，可以分为如下两种格式:

在成员位置称为成员内部类

在局部位置称为局部内部类

例:

class Outer
{
    //成员内部类
    class Inner
    {
    }
    public void method()
    {
        //局部内部类
        class Inner
        {
        }
    }
}

外界创建成员内部类对象的格式:

外部类名.内部类名对象名 = 外部类对象.内部类对象;

例:

class Outer
{
    private int num = 10;
    //成员内部类
    class Inner
    {
        public void show()
        {
            System.out.println(num);
        }
    }
}
class Demo
{
    public static void main(String[] args)
    {
        //访问Inner类的show()方法
　　　　 //外部类名.内部类名 对象名 = 外部类对象.内部类对象;
        Outer.Inner oi = new Outer().new Inner();
        oi.show();
    }
}

10.20 成员内部类的常见修饰符及应用

成员内部类的常见修饰符

1.private 为了保证数据的安全性

例:

class Outer
{
    //成员内部类，私有
    private class Inner
    {
        public void show()
        {
            System.out.println("满足条件输出");
        }
    }
    public void method(int num)
    {
        if(num > 0)
        {
            Inner i = new Inner();
            i.show();
        }
    }
}
class Demo
{
    public static void main(String[] args)
    {
        Outer o = new Outer();
        o.method(-8);
    }
}

上例中，只有当method方法传入的参数大于0时，才可以创建内部类的对象调用方法，否则不创建

2.static 为了让数据访问更方便

• 被静态修饰的成员内部类只能访问外部类的静态成员
• 内部类被静态修饰后的方法可以有静态方法也可以有非静态方法

例:

class Outer
{
    private static int num = 10;
    //成员内部类，静态
    public static class Inner
    {
        //静态方法
        public static void show1()
        {
            System.out.println(num);
        }
        //非静态方法
        public void show2()
        {
            System.out.println(num);
        }
    }
}
class Demo
{
    public static void main(String[] args)
    {
        //成员内部类被静态修饰后的访问方式:
        //外部类名.内部类名 对象名 = new 外部类名.内部类名();
        Outer.Inner oi = new Outer.Inner();
        oi.show1();
        oi.show2();

        //静态方法show1()的另一种调用方式
        Outer.Inner.show1();
    }
}

10.21 成员内部类的面试题

分别输出30、20、10

class Outer
{
    public int num = 10;
    class Inner
    {
        public int num = 20;
        public void show()
        {
            int num = 30;
            System.out.println(num);//30
            System.out.println(this.num);//20
            System.out.println(new Outer().num);//10
            System.out.println(Outer.this.num);//10
        }
    }
}
class Demo
{
    public static void main(String[] args)
    {
        Outer.Inner oi = new Outer().new Inner();
        oi.show();
    }
}

10.22 局部内部类访问局部变量的问题

1.可以直接访问外部类的成员

2.在局部位置可以创建内部类对象，通过对象调用内部类方法，来使用局部内部类功能

例:

class Outer
{
    private int num = 10;
    public void method()
    {
        //局部内部类
        class Inner
        {
            public void show()
            {
                //可以直接访问外部类的成员
                System.out.println(num);
            }
        }
        //在局部位置创建内部类对象
        Inner i = new Inner();
        //通过对象调用内部类方法
        i.show();
    }
}
class Demo
{
    public static void main(String[] args)
    {
        Outer o = new Outer();
        o.method();
    }
}

局部内部类访问局部变量的注意事项:

例:

class Outer
{
    public void method()
    {
        //局部变量
        final int num = 20;
        //局部内部类
        class Inner
        {
            public void show()
            {
                //局部内部类访问局部变量，该局部变量必须被声明为最终类型
                System.out.println(num);
            }
        }

        Inner i = new Inner();
        i.show();
    }
}
class Demo
{
    public static void main(String[] args)
    {
        Outer o = new Outer();
        o.method();
    }
}

因为局部变量会随着方法的调用完毕而消失，这个时候，局部对象并没有立马从堆内存中消失，还要使用那个变量。为了让数据还能继续被使用，就用fianl修饰，这样，在堆内存里面存储的其实是一个常量值。

10.23 匿名内部类的格式和理解

匿名内部类就是内部类的简化写法。

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

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

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

例:

10.24 匿名内部类的方法调用

例:

interface Inter
{
    public abstract void show1();
    public abstract void show2();
}
class Outer
{
    public void method()
    {
        /* 一个方法的调用
        new Inter()
        {
            public void show1()
            {
                System.out.println("show1");
            }
        }.show1();
        */
        //两个方法的调用
        Inter i = new Inter()
        {
            public void show1()
            {
                System.out.println("show1");
            }
            public void show2()
            {
                System.out.println("show2");
            }
        };
        i.show1();
        i.show2();
    }
}
class Demo
{
    public static void main(String[] args)
    {
        Outer o = new Outer();
        o.method();
    }
}

10.25 匿名内部类在开发中的应用

例:

interface Person
{
    public abstract void study();
}
class PersonDemo
{
    public void method(Person p)
    {
        p.study();
    }
}
class Demo
{
    public static void main(String[] args)
    {
        PersonDemo pd = new PersonDemo();
        pd.method(new Person()
        {
            public void study()
            {
                System.out.println("好好学习");
            }
        });
    }
}

当函数参数是接口类型时，而且接口中的方法不超过三个，可以用匿名内部类作为实际参数进行传递

10.26 匿名内部类的面试题

按照要求，补齐代码，要求在控制台输出”HelloWorld”

interface Inter 
{ 
    void show(); 
}
class Outer 
{ 
    //补齐代码 
}
class Demo
{
    public static void main(String[] args)
    {
        Outer.method().show();
    }
}

补齐代码:

/*
分析:
1:Outer.method()可以看出method()是Outer中的一个静态方法
2:Outer.method().show()可以看出method()方法的返回值是一个对象。
又由于接口Inter中有一个show()方法,所以method()方法的返回值类型是一个接口。
*/
interface Inter 
{ 
    void show(); 
}
class Outer 
{ 
    //补齐代码 
    public static Inter method()
    {
        return new Inter()
        {
            public void show()
            {
                System.out.println("helloworld");
            }
        };
    }
}
class Demo
{
    public static void main(String[] args)
    {
        Outer.method().show();
    }
}