传参(参数传递)
类名作为形式参数
如果你以后看到一个方法的形参要一个“类”类型,就传一个该类对象
public class MyTest {
public static void main(String[] args) {
Student student = new Student();
student.show(new Student(),20);
System.out.println(student.num);
}
}
class Student{
int num= 10;
public void show(Student stu, int num){
stu.num=num;
}
}
抽象类名作为形式参数
如果你以后看到一个方法的形参要一个“抽象类类型”,就传该类的子类对象
public class MyTest2 {
public static void main(String[] args) {
Dog dog = new Dog();
setMethod(dog,114);
}
private static void setMethod(Animal an,int num) {
an.show(num);
}
}
abstract class Animal{
int num=110;
public abstract void show(int a);
}
class Dog extends Animal{
int num=20;
@Override
public void show(int num) {
System.out.println(num);
System.out.println(this.num);
System.out.println(super.num);
}
}
接口名作为形式参数
如果你以后看到一个方法的形参要一个“接口”类型,你就穿一个接口的子类对象
public class MyTest3 {
public static void main(String[] args) {
MyClass myClass = new MyClass();
test(myClass,22);
}
private static void test(Myinterface myinterface,int b) {
myinterface.show(b);
}
}
interface Myinterface{
int NUM=100;
void show(int a);
}
class MyClass implements Myinterface{
int a = 10;
@Override
public void show(int a) {
System.out.println(a);
System.out.println(this.a);
System.out.println(NUM);
System.out.println(Myinterface.NUM);
}
}
返回值
类名作为返回值类型
如果你看到一个方法的返回值类型,要一个“类”类型,你就返回一个该类对象
public class MyTest4 {
public static void main(String[] args) {
School school = new School();
school.num=20;
School school1 = school.getSchool(school, 111);
System.out.println(school1.num);
System.out.println(school==school1);
}
}
class School{
int num =10;
public School getSchool(School school,int num){
this.num=num;
School school2 = new School();
return this;
}
}
接口名作为返回值类型
public class MyTest5 {
public static void main(String[] args) {
Myinterface1 anInterface = getInterface(10);
anInterface.show(1000);
}
private static Myinterface1 getInterface(int num) {
num=11;
return new MyClass1();
}
}
interface Myinterface1{
void show(int num);
}
class MyClass1 implements Myinterface1{
@Override
public void show(int num) {
System.out.println(num);
}
}
抽象类名作为返回值类型
如果你以后看到一个方法的返回值类型,要一个“抽象类”类型,你返回一个该抽象类的子类对象
public class MyTest6 {
public static void main(String[] args) {
Animal1 animal = getAnimal(new Tiger());
animal.test();
}
private static Animal1 getAnimal(Tiger tiger) {
return tiger;
}
}
abstract class Animal1{
public abstract void test();
}
class Tiger extends Animal1{
@Override
public void test() {
System.out.println("abc");
}
}