1. 参数传递
1.1 类名作为形参和返回值（应用）
-
1、类名作为方法的形参
方法的形参是类名，其实需要的是该类的对象
实际传递的是该对象的【地址值】
class Cat { public void eat() { System.out.println("猫吃鱼"); } } class CatOperator { public void useCat(Cat c) { //Cat c = new Cat(); c.eat(); } public Cat getCat() { Cat c = new Cat(); return c; } } public class CatDemo { public static void main(String[] args) { //创建操作类对象，并调用方法 CatOperator co = new CatOperator(); Cat c = new Cat(); co.useCat(c); Cat c2 = co.getCat(); //new Cat() c2.eat(); }
1.2 抽象类作为形参和返回值
-
抽象类作为形参和返回值
-
方法的形参是抽象类名，其实需要的是该抽象类的子类对象
-
方法的返回值是抽象类名，其实返回的是该抽象类的子类对象
abstract class Animal { public abstract void eat(); } class Cat extends Animal { @Override public void eat() { System.out.println("猫吃鱼"); } } class AnimalOperator { public void useAnimal(Animal a) { //Animal a = new Cat(); a.eat(); } public Animal getAnimal() { Animal a = new Cat(); return a; } } public class AnimalDemo { public static void main(String[] args) { //创建操作类对象，并调用方法 AnimalOperator ao = new AnimalOperator(); Animal a = new Cat(); ao.useAnimal(a); Animal a2 = ao.getAnimal(); //new Cat() a2.eat(); } }1.3 接口名作为形参和返回值
-
接口作为形参和返回值
-
方法的形参是接口名，其实需要的是该接口的实现类对象
-
方法的返回值是接口名，其实返回的是该接口的实现类对象
interface Jumpping { void jump(); } class JumppingOperator { public void useJumpping(Jumpping j) { //Jumpping j = new Cat(); j.jump(); } public Jumpping getJumpping() { Jumpping j = new Cat(); return j; } } class Cat implements Jumpping { @Override public void jump() { System.out.println("猫可以跳高了"); } } public class JumppingDemo { public static void main(String[] args) { //创建操作类对象，并调用方法 JumppingOperator jo = new JumppingOperator(); Jumpping j = new Cat(); jo.useJumpping(j); Jumpping j2 = jo.getJumpping(); //new Cat() j2.jump(); } }
-
-
2. 内部类
2.1 内部类的基本使用
-
内部类概念
-
在一个类中定义一个类。举例：在一个类A的内部定义一个类B，类B就被称为内部类
-
-
内部类定义格式
/* 格式： class 外部类名{ 修饰符 class 内部类名{ } } */ class Outer { public class Inner { } }
内部类的访问特点
-
内部类可以直接访问外部类的成员，包括私有
-
外部类要访问内部类的成员，必须创建对象
/* 内部类访问特点： 内部类可以直接访问外部类的成员，包括私有 外部类要访问内部类的成员，必须创建对象 */ public class Outer { private int num = 10; public class Inner { public void show() { System.out.println(num); } } public void method() { Inner i = new Inner(); i.show(); } }2.2 成员内部类
-
成员内部类的定义位置
-
在类中方法，跟成员变量是一个位置
-
-
外界创建成员内部类格式
-
格式：外部类名.内部类名 对象名 = 外部类对象.内部类对象;
-
举例：Outer.Inner oi = new Outer().new Inner();
-
-
成员内部类的推荐使用方案
-
将一个类，设计为内部类的目的，大多数都是不想让外界去访问，所以内部类的定义应该私有化，私有化之后，再提供一个可以让外界调用的方法，方法内部创建内部类对象并调用。
class Outer { private int num = 10; private class Inner { public void show() { System.out.println(num); } } public void method() { Inner i = new Inner(); i.show(); } } public class InnerDemo { public static void main(String[] args) { //Outer.Inner oi = new Outer().new Inner(); //oi.show(); Outer o = new Outer(); o.method(); } }
-
2.3 局部内部类
-
局部内部类定义位置
-
局部内部类是在方法中定义的类
-
-
局部内部类定义方式
-
局部内部类，外界是无法直接使用，需要在方法内部创建对象并使用
-
该类可以直接访问外部类的成员，也可以访问方法内的局部变量
class Outer { private int num = 10; public void method() { int num2 = 20; class Inner { public void show() { System.out.println(num); System.out.println(num2); } } Inner i = new Inner(); i.show(); } } public class OuterDemo { public static void main(String[] args) { Outer o = new Outer(); o.method(); } }
-
2.4 匿名内部类
-
匿名内部类的前提
-
存在一个类或者接口，这里的类可以是具体类也可以是抽象类
-
-
匿名内部类的格式
-
格式：new 类名 ( ) { 重写方法 } new 接口名 ( ) { 重写方法 }
new Inter(){ @Override public void method(){} }
-
-
匿名内部类的本质
-
本质：是一个继承了该类或者实现了该接口的子类匿名对象
-
-
匿名内部类的细节
-
匿名内部类可以通过多态的形式接收
Inter i = new Inter(){ @Override public void method(){ } }
-
匿名内部类直接调用方法
interface Inter{
void method();
}
class Test{
public static void main(String[] args){
new Inter(){
@Override
public void method(){
System.out.println("我是匿名内部类");
}
}.method(); // 直接调用方法
}
}2.4 匿名内部类在开发中的使用
-
匿名内部类在开发中的使用
-
当发现某个方法需要，接口或抽象类的子类对象，我们就可以传递一个匿名内部类过去，来简化传统的代码
interface Jumpping { void jump(); } class Cat implements Jumpping { @Override public void jump() { System.out.println("猫可以跳高了"); } } class Dog implements Jumpping { @Override public void jump() { System.out.println("狗可以跳高了"); } } class JumppingOperator { public void method(Jumpping j) { //new Cat(); new Dog(); j.jump(); } } class JumppingDemo { public static void main(String[] args) { //需求：创建接口操作类的对象，调用method方法 JumppingOperator jo = new JumppingOperator(); Jumpping j = new Cat(); jo.method(j); Jumpping j2 = new Dog(); jo.method(j2); System.out.println("--------"); // 匿名内部类的简化 jo.method(new Jumpping() { @Override public void jump() { System.out.println("猫可以跳高了"); } }); // 匿名内部类的简化 jo.method(new Jumpping() { @Override public void jump() { System.out.println("狗可以跳高了"); } }); } }
-
综合案例
我们现在有乒乓球运动员和篮球运动员，乒乓球教练和篮球教练。
为了出国交流，跟乒乓球相关的人员都需要学习英语。
请用所学知识分析，这个案例中有哪些具体类，哪些抽象类，哪些接口，并用形参和返回值以及匿名内部类方式的代码实现。
人类
package com.itheima_02;
//抽象人类
public 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 abstract void eat();
}
运动员类
package com.itheima_02;
//抽象运动员类
public abstract class Player extends Person {
public Player() {
}
public Player(String name, int age) {
super(name, age);
}
//运动员擅长什么
public abstract void study();
}
教练类
package com.itheima_02;
//抽象教练类
public abstract class Coach extends Person {
public Coach() {
}
public Coach(String name, int age) {
super(name, age);
}
// 教练擅长什么
public abstract void teach();
}
学习英语接口类
package com.itheima_02;
//说英语的接口
public interface SpeakEnglish {
//会英语的技能的人
public abstract void speak();
}
操作类
package com.itheima_02;
public class PersonOperator {
class PingPangPlayer{
Person ppp = new Coach() {
@Override
public void eat() {
System.out.println("乒乓球教练吃小白菜，喝大米粥");
}
@Override
public void teach() {
System.out.println("乒乓球教练教如何发球和接球");
}
};
SpeakEnglish pps =new SpeakEnglish() {
@Override
public void speak() {
System.out.println("乒乓球教练说英语");
}
};
}
public void method(){
PingPangPlayer ppp = new PingPangPlayer();
ppp.ppp.eat();
Coach c =(Coach) ppp.ppp;
c.teach();
ppp.pps.speak();
}
public void method( Person p,SpeakEnglish se,String name){
p.eat();
if (name == "Coach"){
Coach pc = (Coach) p;
pc.teach();
}
if (name == "Player"){
Player pp= (Player)p;
pp.study();
}
se.speak();
}
class PingPangPlayerOperator{
public Person getPingPangPlayer(){
Person p = new Player(){
@Override
public void study() {
System.out.println("乒乓球运动员学习如何发球和接球");
}
@Override
public void eat() {
System.out.println("乒乓球运动员吃大白菜，喝小米粥");
}
};
return p;
};
public SpeakEnglish getPingPangPlayerInter() {
SpeakEnglish se = new SpeakEnglish() {
@Override
public void speak() {
System.out.println("乒乓球运动员说英语");
}
};
return se;
};
}
public PingPangPlayerOperator getPingPangPlayer(){
PingPangPlayerOperator ppp = new PingPangPlayerOperator();
return ppp;
}
}
测试类
package com.itheima_02;
public class PersonDemo {
public static void main(String[] args) {
PersonOperator po = new PersonOperator();
po.method();
System.out.println("=======");
PersonOperator.PingPangPlayerOperator ppp = po.getPingPangPlayer();
Person p = ppp.getPingPangPlayer();
p.eat();
Player p2 = (Player) p;
p2.study();
SpeakEnglish pppi = ppp.getPingPangPlayerInter();
pppi.speak();
System.out.println("=======");
PersonOperator bc = new PersonOperator();
bc.method(new Coach() {
@Override
public void teach() {
System.out.println("篮球教练教如何运球和投篮");
}
@Override
public void eat() {
System.out.println("篮球教练吃羊肉，喝羊奶");
}
}, new SpeakEnglish() {
@Override
public void speak() {
System.out.println("篮球教练不需要会说英语");
}
},"Coach");
System.out.println("=======");
PersonOperator bp = new PersonOperator();
bp.method(new Player() {
@Override
public void study() {
System.out.println("篮球运动员学习如何运球和投篮");
}
@Override
public void eat() {
System.out.println("篮球运动员吃牛肉，喝牛奶");
}
}, new SpeakEnglish() {
@Override
public void speak() {
System.out.println("篮球运动员不需要会说英语");
}
},"Player");
}
}
版权声明：本文内容由互联网用户自发贡献，该文观点仅代表作者本人。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如发现本站有涉嫌侵权/违法违规的内容， 请发送邮件至 举报，一经查实，本站将立刻删除。
文章由极客之音整理，本文链接：https://www.bmabk.com/index.php/post/82000.html
