它名叫阿福，整天跟着我
在我最最难过的时候
一、返回类型
1、普通类
当普通类作为形式参数或返回值，需要的是该类的实例对象
1.1 作为形参
//普通类
class Student1{
public void study(){
System.out.println("fgh");
}
}
//普通类，方法将普通类作为形参
class StudentDemo1{
//方法的参数是一个类当作数据类型传参的时候
//实际上传的是该类的实例对象的地址值
public void fun(Student1 test){
test.study();
}
}
public class StudentTest1 {
public static void main(String[] args) {
StudentDemo1 address1 = new StudentDemo1();
Student1 address2 = new Student1();
address1.fun(address2);
}
}
1.2 作为返回值
class Student2{
public void study(){
System.out.println("好好学习，天天向上！");
}
}
//将普通类作为返回值类型
class StduentDemo2{
public Student2 getStudent(){
//Student4 student4 = new Student4();
//return student4;
//用匿名对象改进
return new Student2();
}
}
public class StudentTest2 {
public static void main(String[] args) {
StduentDemo2 address1 = new StduentDemo2();
//利用方法返回的类，创建一个新类
Student2 address2 = address1.getStudent();
address2.study();
}
}
2、抽象类
当抽象类作为形式参数或返回值，需要的是该抽象类的子类对象
2.1 作为形参
//抽象类
abstract class Person1{
public abstract void study();
}
//方法将抽象类对象作为形参
class PersonDemo{
//一个方法的参数是抽象类作为数据类型参数传进来的时候
//实际上需要的是该抽象类的子类对象的地址值
public void fun(Person1 test){
test.study();
}
}
//抽象类子类
class Student3 extends Person1{
@Override
public void study() {
System.out.println("fgh");
}
}
public class PersonTest1 {
public static void main(String[] args) {
//普通类对象
PersonDemo address1 = new PersonDemo();
//抽象类子类对象
Person1 address2 = new Student3();
//将子类对象作为形参，实现普通类方法
address1.fun(address2);
}
}
2.2 作为返回值
//抽象类
abstract class Person2{
public abstract void study();
}
//普通类，方法将抽象类作为返回值类型
class PersonDemo2{
public Person2 fun(){
// Person5 p = new Programmer();
// return p;
//匿名对象改进
return new Programmer();
}
}
//抽象类子类
class Programmer extends Person2{
@Override
public void study() {
System.out.println("程序员学习技术");
}
}
public class PersonTest2 {
public static void main(String[] args) {
//普通类对象
PersonDemo2 address1 = new PersonDemo2();
//Person2 p = new Programmer();
//利用普通类的方法返回值，创建一个抽象类子类对象
Person2 p = address1.fun();
p.study();
}
}
3、接口
当接口作为形式参数或返回值，需要的是该接口具体的实现类的对象
2.1 作为形参
//接口
interface Teacher1{
public abstract void study();
}
//普通类，方法将接口作为形参
class TeacherDemo{
public void fun(Teacher1 test){
test.study();
}
}
//接口实现类
class Teacher4 implements Teacher1{
@Override
public void study() {
System.out.println("fgh");
}
}
public class TeacherTest1 {
public static void main(String[] args) {
TeacherDemo teacherDemo = new TeacherDemo();
Teacher1 p = new Teacher4();
teacherDemo.fun(p);
}
}
2.2 作为返回值
//接口
interface PlayGame{
public abstract void playLol();
}
//普通类，方法将接口作为返回值类型
class PlayGameDemo{
public PlayGame fun(){
//PlayGame pg = new Teacher2();
//return pg;
//返回匿名对象
return new Teacher2();
}
}
//接口实现类
class Teacher2 implements PlayGame{
@Override
public void playLol() {
System.out.println("打英雄联盟");
}
}
public class TeacherTest2 {
public static void main(String[] args) {
PlayGameDemo address = new PlayGameDemo();
//利用普通类方法的返回值，创建一个接口实现类对象
PlayGame pg = address.fun();
pg.playLol();
}
}
2、链式编程
1、对象1.对象2.对象3…方法()
2、对象1.方法1().方法2()…方法n()
interface PlayGame2{
public abstract void playLol();
}
class PlayGameDemo2{
//方法返回接口类型
public PlayGame2 fun(){
PlayGame2 pg2 = new Student4();
return pg2;
}
}
class Student4 implements PlayGame2{
@Override
public void playLol() {
System.out.println("打英雄联盟");
}
}
public class ChainTest {
public static void main(String[] args) {
PlayGameDemo2 address1 = new PlayGameDemo2();
PlayGame2 pg2 = address1.fun();
pg2.playLol();
System.out.println("==========用链式编程改进===========");
//每次调用完毕方法之后，返回的是一个对象
//因为对象才能去调用方法
address1.fun().playLol();
}
}
3、包
package 包名;
多级包用 . 分开即可
表示当前代码文件的相对目录
相对路径：com.shujia.java.day13.BaoDemo
绝对路径：D:\IdeaProjects\bigdata13\src\com\shujia\java\day13\BaoDemo.java
注意事项：
package语句必须是程序的第一条可执行的代码
package语句在一个java文件中只能有一个
如果没有package，默认表示无包名
package，import，class
package 在Java文件的第一行，在import和class之前出现
import 在package之后，在class出现之前
class是最后出现的，也就是我们所写的程序代码
总结
当普通类作为形式参数或返回值，需要的是该类的实例对象
当抽象类作为形式参数或返回值，需要的是该抽象类的子类对象
当接口作为形式参数或返回值，需要的是该接口具体的实现类的对象