类名作为形参和返回值
- 方法的形参是类名，其实需要的是该类的对象
- 方法的返回值是类名，其实返回的是该类的对象
public class Cat{
public void eat(){
System.out.println("猫吃鱼");
}
}public class CatDemo{
public static void main(String[] args){
//创建操作类对象，并调用方法
CatOperator co=new CatOperator();
Cat c= new Cat();
co.useCat(c);//使用CatOperator类对象进行调用CatOperator类的函数，此函数用Cat类对象作为形参
Cat c2=co.getCat();//调用类名作为返回值的函数创建一个Cat类的对象c2
c2.eat();
}
}
//此代码运行结果为
猫吃鱼
猫吃鱼public cass CatOperator{
public void useCat(Cat c){//Cat c=new Cat();
c.eat();
}//类名作为形参，其实它要的是该类的对象
public Cat getCat(){
Cat c=new Cat();
return c;
}//类名作为返回值
}抽象类名作为形参和返回值
- 方法的形参是抽象类名，其实需要的是该抽象类的子类对象
- 方法的返回值是抽象类名，其实返回的是该抽象类的子类对象
public class AnimalDemo{
public static void main(String[] args){
//创建操作类对象，并调用方法
AnimalOperator ao=new AnimalOperator();
Animal a=new Cat();
ao.useAnimal(a);//使用AnimalOperator对象ao去调用抽象类名为形参的函数
Animal a2=ao.getAnimal();//new Cat()
}
}
//此代码运行结果为
猫吃鱼public class AnimalOperator{
public void useAnimal(Animal a){//Animal a=new Cat();
a.eat();
}
public void getAnimal(){
Animal a=new Cat();
return a;
}
}public abstract class Animal{
public absrtact void eat();
}public class Cat extends Animal{
@override
public void eat(){
System.out.println("猫吃鱼");
}
}接口名作为形参和返回值
- 方法的形参是接口名，其实需要的是该接口的实现类的对象
- 方法的返回值是接口名，其实返回的是该接口的实现类的对象
pubilc class JumppingOperator{
public void useJumpping(Jumpping j){//Jumpping j=new Cat();
j.jump();
}
public Jumpping getJumpping(){
Jumpping j=new Cat();
return j;
}
}
public class Cat implements Jumpping{
@override
public void jump(){
System.out.println("猫可以跳高了");
}
}public interface Jumpping{
void jump();//接口的方法默认为public abstract修饰
}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();
}
}
//此代码运行结果为
猫可以跳高了
猫可以调高了内部类
内部类就是在一个类中定义一个类。举例：在一个类A的内部定义一个类B，类B就被成为内部类
- 内部类的定义格式
public class 类名
修饰符 class 类名{
}
}- 内部类的访问特点
- 内部类可以直接访问外部类的成员，包括私有
- 外部类要访问内部类，必须创建内部类对象访问
public class Outer{
private int num=10;
public class Inner{
public void show(){
System.out.println(num);
}
}
public void method(){
//show();//外部类不能直接访问内部类的成员
Inner i=new Inner();//外部类访问内部类的成员必须要创建内部类对象访问
i.show
}
}成员内部类
按照内部类在类中的定义的位置不同，可以分为如下两种形式
(方法里面和外面定义的类，分别叫作成员内部类，局部内部类)
- 在类的成员位置：成员内部类
- 在类的局部位置：局部内部类
成员内部类如何创建对象使用？
格式：外部类名.内部类名 对象名=外部类对象.内部类对象;
例如：Outer.Inner oi=new Outer().new 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();
}//外部类创建一个方法用来调用内部类的方法
}public calss InnerDemo{
public static void main(String[] args){
//创建内部类对象，并调用方法
//Inner i=new Inner();//内部类对象不能直接这样创建
Outer.Inner oi=new Outer().new Inner();//创建内部类对象
oi.show();//内部类对象调用内部类的方法
}
}局部内部类
局部内部类是在方法中定义的类，所以外界是无法直接使用的，需要在内部类所在的方法中创建内部类对象使用
该类可以直接访问外部类的成员，也可以访问所在方法内的局部变量
public 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;
}
}
//此代码运行结果为
10
20匿名内部类
匿名内部类是局部内部类的一种特殊形式，匿名内部类本质是一个对象。
前提：存在一个类或者接口，这里的类可以是具体类也可以是抽象类
格式：
new 类名或者接口名(){
重写方法;
};例如：
new Inner(){
public void show(){
.......
}
};
