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 内部类的基本使用
内部类概念
在一个类中定义另一个类
格式：
class 外部类名{
修饰符 class 内部类名 {
}
}
访问：
内部类可以直接访问外部类的成员、方法包括私有的外部类要访问内部类，必须通过对象
2.2 成员内部类
位置：
在类中方法，跟成员变量是一个位置 外界创建成员内部类格式
格式： 外部类名.内部类型 对象名 = 外部类对象.内部类对象; 成员内部类的推荐使用方案
将一个类，设计为内部类的目的，大部分是不想让外界访问，所以内部类的定义应该是私有化，私有化之后，在提供一个可以让外界调用的方法，方法内部类对象并调用
package com.bdit.test;
public class Test04 {
public static void main(String[] args) {
External external = new External();
external.informa01("张三",20);
external.aa();
// external.informa02();
//使用内部类
External.Interior interior01 = new External().new Interior();
interior01.Interfor();
interior01.iorfor01();
interior01.iorfor02("甲一",12);
}
}
//定义外部类
class External{
private String name;
private int age;
String compellation = "王五";
int aagee = 10;
public void informa01(String name,int age){
System.out.println("外部类姓名："+name+"，外部类年龄："+age);
}
//外部类使用内部类，需要使用对象
Interior interior02 = new Interior();
public void aa(){
System.out.println("外部类姓名："+compellation+"，外部类年龄："+aagee+"，内部类地址："+interior02.site);
}
//定义内部类
public class Interior{
String site = "中国";
public void Interfor(){
System.out.println("内部类地址："+site);
}
//内部类可以直接使用外部类的方法和属性甚至是私有的
public void iorfor01(){
System.out.println("内部类姓名："+compellation+"，内部类年龄："+aagee+"，内部类地址："+site);
}//内部类使用外部类私有属性
public void iorfor02(String name,int age){
System.out.println("内部类姓名："+name+"，内部类年龄："+age+"，内部类地址："+site);
}
}
}
2.3 局部内部类
局部内部类定义位置
局部内部类是在方法中定义的类 局部内部类方式方式
局部内部类，外界是无法直接使用，需要在方法内部创建对象并使用该类可以直接访问外部类的成员，也可以访问方法内的局部变量 示例：
package com.bdit.test;
public class Test05 {
public static void main(String[] args) {
Outside outside = new Outside();
outside.Common();
outside.inner();
}
}
class Outside{
private String name = "张三";
int age = 20;
public void Common(){
System.out.println("外层类的普通方法");
}
//定义局部内部类
public void inner(){
int weight = 60;
class InnerClass{
//在局部内部类中可以直接访问外部类中的方法、属性、包括私有的
private String sit = "山东";
int hright = 120;
public void Internal(){
System.out.println("局部内部类的姓名："+name+"，局部内部类的年龄："+age+"，局部内部类的体重："+weight+"，局部内部类的身高："+hright+"，局部内部类的地址："+sit);
Common();//访问外部类的方法
}
}
//调用局部内部类
InnerClass innerClass = new InnerClass();
innerClass.Internal();
}
}
2.4 匿名内部类
1、
前提：
存在一个类或者接口，这个类可以实具体的也可使抽象的 匿名内部类的格式
new 类名(){重写方法}; 本质
是一个继承了该类或者实现了该接口的子类匿名对象 细节
匿名内部类可以通过多态的形式接受
2、
匿名内部类在开发中使用
当发现某个方法需要，接口或抽象类子类对象，我们就可以传递一个匿名内部类过去。
3、
示例：
package com.bdit.test;
public class Test06 {
public static void main(String[] args) {
//定义匿名类(一般用于抽象类和接口类)
//new 接口/抽象类名(){};
//调用方法则需在{}后面 .方法名 即可
new Abstra01(){
@Override
public void abject01() {
System.out.println("重写抽象类中的方法");
}
}.abject01();
new Port01(){
@Override
public void sum01(int a, int b) {
System.out.println("重写接口类的方法");
System.out.println("a"+"+"+"b"+"="+(a+b));
}
}.sum01(1,2);
}
}
abstract class Abstra01{
public abstract void abject01();
}
interface Port01{
public abstract void sum01(int a,int b);
}
第二种：
package com.bdit.test;
public class Test06_01 {
public static void main(String[] args) {
//参数传递方法的匿名方法(抽象)
Test06_01 test06_01 = new Test06_01();
test06_01.display01(new Abstra02() {
@Override
void abject02() {
System.out.println("重写Abstra02(抽象类)中的abject02(抽象)方法");
}
});
System.out.println("-------------------------------------------------------------");
//参数传递方法的匿名方法(接口)
Test06_01 test06_011 = new Test06_01();
test06_011.display02(new Port02() {
@Override
public void sum02(int a, int b) {
System.out.println("重写Port02(接口类)中的sum02(抽象)方法");
System.out.println("a"+"+"+"b"+"="+(a+b));
}
});
}
//参数接收的抽象方法
public void display01(Abstra02 abstra02){
abstra02.abject02();
}
//参数接收的接口方法
public void display02(Port02 port02){
port02.sum02(1,2);
}
}
abstract class Abstra02{
abstract void abject02();
}
interface Port02{
void sum02(int a,int b);
}
