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);//
             System.out.println(this.num);//
             System.out.println(new Outer().num);//
             System.out.println(Outer.this.num);//
         }
     }
 }
 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();
     }
 }