面向对象（传参与返回值）

最新推荐文章于 2022-06-14 21:17:49 发布

每一刻都是崭新的71

最新推荐文章于 2022-06-14 21:17:49 发布

阅读量349

点赞数 1

分类专栏：新手求指教求一起探讨文章标签： java 面向对象传参返回值

本文链接：https://blog.csdn.net/qq_43298772/article/details/89409449

版权

新手求指教同时被 2 个专栏收录

90 篇文章 2 订阅

订阅专栏

求一起探讨

79 篇文章 0 订阅

订阅专栏

面向对象(类名作为形式参数)

package org.westos.demo2;

/**
 * @Author: Administrator
 * @CreateTime: 2019-04-14 13:44
 */
public class MyTest {
    public static void main(String[] args) {
        Student student = new Student();
        int num=2;
        set(student,num);
        student.show(new Student(),100); //使用了匿名对象
        System.out.println(student.num);

    }

    public static void set(Student student,int num){       //如果你以后看到一个方法的形参要一个类 类型，你就传一个该类的对象
        student.num=num;
    }
}

class Student{
    int num=10;

    public void show(Student student,int num){
        student.num=num;
    }

}

在上述代码中，MyTest类中的set()方法以及自定义类中Student类中的show()成员方法的形参都是要一个类类型，所以在调用这些方法时，传参的时候传该类的一个对象即可
所以上述代码执行结果为

面向对象(抽象类名作为形式参数)

package org.westos.test;

/**
 * @Author: Administrator
 * @CreateTime: 2019-04-13 15:01
 */
public class MyTest {
    public static void main(String[] args) {
        int num=1;
        Zi zi = new Zi();
        //如果你以后看到一个方法的形参要一个抽象类 类型，那么你就传一个该抽象类的子类对象
        set(zi,num);
        zi.show(188);
        System.out.println(zi.num); 
    }

    public static void set(Fu fu,int num){
        fu.num=num;
        System.out.println(fu.num);
    }
}

abstract class Fu{
    int num=100;
    public abstract void show(int num);
}

class Zi extends Fu{
    int num=10;
    @Override
    public void show(int num) {
        this.num=num;
    }
}

在上述代码中某些方法的形参为抽象类类型，那么在调用方法传参的时候传递该抽象类的子类的对象即可，在方法内部可以理解为父类引用指向子类对象，涉及到了多态，多态在之前已经提到过，这里不再解释，所以最终结果为

1
188

面向对象(接口名作为形式参数)

package org.westos.demo4;

/**
 * @Author: Administrator
 * @CreateTime: 2019-04-14 14:00
 */
public class MyTest {
    public static void main(String[] args) {
        int num=1;
        //如果你以后看到一个方法的形参要一个接口类型，你要传一个该接口的子类对象
        B b = new B();
        set(b,num);
        System.out.println(b.a);                           
        System.out.println(b.NUM); 
        System.out.println(A.NUM); 
        System.out.println(B.NUM); 

    }
    public static void set(A a,int num){
       new B().a=num;
       a.show(num);

    }
}

interface A{
    public static final int NUM=100;
    void show(int num);
}

class B implements A{
        int a=10;

    @Override
    public void show(int num) {
        this.a=num;
    }
}

NUM为静态常量，所以建议通过类名来调用，所以上述代码执行结果为

面向对象(类名作为返回值类型)

package org.westos.test;
/**
 * @Author: Administrator
 * @CreateTime: 2019-04-13 15:01
 */

public class MyTest {
    public static void main(String[] args) {
        int num = 100;
        A a = new A();
        A a1 = a.getA(num);
        System.out.println(a.num);
        System.out.println(a1.num); 
        System.out.println(a);
        System.out.println(a1);
        System.out.println(a == a1);
    }

    public static A getAA(A a, int num) {
        a.num = num;
        return a;
    }
}

class A {
    int num = 1;

    //如果你以后看到一个方法的返回值类型 是一个 类 类型，你就返回该类的一个对象
    public A getA(int num) {
        A a = new A();
        a.num = num;
        //  return a;
        return this;
    }
}

根据之前的讲解可知该代码最终的执行结果为

1
1
org.westos.test.A@1540e19d
org.westos.test.A@1540e19d
true

java语言虽然不讲指针，但是处处是指针，有该 A a1 = a.getA(num);代码知局部变量a中的地址值又被赋给了a1，所以两个相等。

面向对象(抽象类名作为返回值类型)

public class MyTest {
    public static void main(String[] args) {
        Zi zi = new Zi();
        Fu fu = zi.getFu(zi, 109);
        System.out.println(zi.num); //109
        System.out.println(fu.num); //109
        System.out.println(zi);
        System.out.println(fu);
    }
}

abstract class Fu {
    int num = 10;
}

class Zi extends Fu {
    int num = 100;
    //如果你以后看到一个方法的返回值类型，要一个抽象类 类型，你就返回一个该抽象类的子类对象
    public Fu getFu(Fu fu, int num) {
        fu.num = num;
        // return new Zi();
        return this;
    }
}

上述代码存在方法的返回值类型为抽象类，返回接口的子类的一个对象就行，代码执行结果为：

100
109
org.westos.test.Zi@1540e19d
org.westos.test.Zi@1540e19d

面向对象(接口名作为返回值类型)

	package org.westos.test;


/**
 * @Author: Administrator
 * @CreateTime: 2019-04-13 15:01
 */

public class MyTest {
    public static void main(String[] args) {
        MyClass myClass = new MyClass();

        int num=2;

        MyInterface myInterface = get(myClass, num);

        myClass.show(109);

        System.out.println(myClass.num); //109

        System.out.println(myInterface.NUM);//100

    }
    //如果你以后看到一个方法的返回值类型，要一个接口类型，你就返回该接口的一个子类对象
    public static MyInterface get(MyClass myClass,int num){
        myClass.num=num;
        return myClass;
    }

}

interface MyInterface{
    int NUM=100;
    void show(int num);
}

class MyClass implements MyInterface{
    int num=1;
    @Override
    public void show(int num) {
        this.num=num;
    }
}

上述代码存在方法的返回值为接口类型，所以最终只需要返回该抽象类的子类的一个对象就行，所以上述代码的最终执行结果为：

109
100

面向对象(链式编程)

package org.westos.demo8;

/**
 * @Author: Administrator
 * @CreateTime: 2019-04-14 14:43
 */
public class MyTest {
    public static void main(String[] args) {
        //链式编程
        //Student student = new Student();
        //Student student1 = student.getStudent(new Student(), 100);
        //student1.show(109);
        //链式编程：当你调用完一个方法之后，方法的返回值又是一个对象，那么你就可以紧接着打点再去调用对象的方法
        Student student = new Student();
        new Student().getStudent(student, 100).show(109);
        System.out.println(student.num); //
    }
}


class Student {
    int num = 10;

    public Student getStudent(Student stu, int num) {
        stu.num = num;
        return this;
    }

    public void show(int num) {
        this.num = num;
    }
}

面向对象(package关键字的概述及作用)

包的概述: 就是文件夹

包的作用: 用来解决同一个路径下不能存在同名文件的问题(分类管理)

包的划分:

按照功能
按照模块

面向对象(包的定义及注意事项)

定义包的格式：

   package 包名;

多级包用.分开即可

定义包的注意事项：

package语句必须是程序的第一条可执行的代码
package语句在一个java文件中只能有一个
如果没有package，默认表示无包名

面向对象(`import`关键字的概述和使用)

导包的概述：
不同包下的类之间的访问，我们发现，每次使用不同包下的类的时候，都需要加包的全路径。比较麻烦。这个时候，java就提供了导包的功能

导包格式

import 包名;

注意：

这种方式导入是到类的名称。
虽然可以最后写*，但是不建议。

面向对象(四种权限修饰符的测试)

四种权限修饰符: private(私有的) , 默认 , protected(受保护的) , public(公共的)

	本类	同一个包下(子类和无关类)	不同包下(子类)	public(公共的)
private	Y
默认	Y	Y
protected	Y	Y	Y
public	Y	Y	Y	Y

面向对象(类及其组成所使用的常见修饰符)

修饰符：

权限修饰符：private，默认的，protected，public
状态修饰符：static，final
抽象修饰符：abstract

修饰类的关键字：

权限修饰符：默认修饰符，public
状态修饰符：final
抽象修饰符：abstract
用的最多的就是：public

修饰成员变量的关键字：

权限修饰符：private，默认的，protected，public
状态修饰符：static，final
用的最多的就是：private

修饰构造方法的关键字：

权限修饰符：private，默认的，protected，public
用的最多的就是：public

修饰成员方法的关键字：

权限修饰符：private，默认的，protected，public
状态修饰符：static，final
抽象修饰符：abstract
用的最多的就是：public

除此以外的组合规则：

成员变量：public static final
成员方法：public static
public abstract
public final

每一刻都是崭新的71

关注

1
点赞
踩
1

收藏

觉得还不错? 一键收藏
0
评论
面向对象（传参与返回值）

面向对象(类名作为形式参数)package org.westos.demo2;/** * @Author: Administrator * @CreateTime: 2019-04-14 13:44 */public class MyTest { public static void main(String[] args) { Student student ...
复制链接

扫一扫