JAVA面对对象常见问题、链式编程、包小结

最新推荐文章于 2025-04-07 18:16:46 发布

君不见代码

最新推荐文章于 2025-04-07 18:16:46 发布

阅读量397

点赞数

本文链接：https://blog.youkuaiyun.com/weixin_35995730/article/details/102691737

版权

本文深入探讨Java编程中的方法参数类型及返回值类型的运用，包括类名、抽象类名和接口名作为参数或返回值的实践案例，以及链式编程的概念与实现。同时，解析Java包的定义、使用和不同包下类的访问规则，阐述权限修饰符的作用范围，并总结类、成员变量、构造方法和成员方法的常见修饰符。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

文章目录

方法参数类型以及返回值类型问题研究

类名作为形式参数：

小结：当你以后看到一个方法的形参要一个类类型，你就传一个该类的对象

示例：

public class MyTest {
    public static void main(String[] args) {
        //多态 抽象类  接口
        //当你以后看到一个方法的形参要一个 类 类型，你就传一个该类的对象
        Student student = new Student();

        setStudent(student,100);

        student.show(new Student(),18);

        System.out.println(student.num); //18
    }

    private static void setStudent(Student student,int num) {
        student.num=num;
    }
}

class Student{
    int num=20;

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

抽象类名作为形式参数:

小结：如果你以后看到一个方法的形参要一个抽象类类型，你就传一个该抽象类的子类对象

示例：

public class MyTest2 {
    public static void main(String[] args) {
        //如果你以后看到一个方法的形参要一个抽象类 类型，你就传一个该抽象类的 子类对象

        MyClasss aa = new AA();

        setMyClss(aa, 200);
        System.out.println(aa.num); //10

    }

    private static void setMyClss(MyClasss myClss, int num) {
        myClss.show(num);
    }
}

abstract class MyClasss {
    int num = 10;

    public abstract void show(int num);
}

class AA extends MyClasss {
    int num = 20;

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

接口名作为形式参数:

小结：如果你以后看到一个方法的形参要一个接口类型，你就传一个该接口的子类对象

示例：

public class MyTest3 {
    public static void main(String[] args) {
        //如果你以后看到一个方法的形参要一个接口类型，你就传一个该接口的子类对象
        MyInterface bb = new BB();
        setInterface(bb,600);
        System.out.println(bb.num);//100
        System.out.println(MyInterface.num); //100
        System.out.println(((BB) (bb)).num);// 600
    }

    private static void setInterface(MyInterface myInterface,int num) {
        myInterface.show(num);

    }
}

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

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

结论1

现象：
不管父类是具体类还是抽象类，亦或者是接口，他们的多态调用的方法都是子类的方法，而且此时this.num改变的都是子类中自己的num，而不是父类的num
原因：
个人以为：如果单纯用多态的方式去调用num属性，那么打印的一定是父类的num值，则如果发生改变，一定改变的也是父类对象的num数值。但是这里调用的是方法，则会将其加载入栈空间执行，此时已经没有父类引用指向字类对象了，就是单纯的this.num，而这个this就是子类对象本身，因为调用的就是子类重写过后的方法！

类名作为返回值类型

结论：如果你以后看到一个方法的返回值类型要一个类类型，你返回一个该类对象

示例：

public class MyTest {
    public static void main(String[] args) {
        Teacher teacher = getTeacher(100);
        Teacher tea = teacher.show(new Teacher(), 500);
        System.out.println(teacher.num); //500
        System.out.println(tea.num);//500
    }

    public static Teacher getTeacher(int num) {
        //如果你以后看到一个方法的返回值类型要一个类 类型，你返回一个该类对象
        Teacher teacher = new Teacher();
        teacher.num = num;

        return teacher;
    }
}

class Teacher {
    int num = 20;

    public Teacher show(Teacher teacher, int num) {
        this.num = num;

        return this;
    }
}

抽象类名作为返回值类型

结论：如果你以后看到一个方法的返回值，要一个抽象类类型，你就返回该抽象类的一个子类对象

示例：

public class MyTest2 {
    public static void main(String[] args) {
        Zi zi = new Zi();
        zi.num = 50;
        CC cc = getCC(zi, 300);
        cc.show(zi, 700);
        System.out.println(cc.num);//20
        Zi zi2 = (Zi) cc;//
        System.out.println(zi2.num);//700
        System.out.println(zi.num);//50
    }

    public static CC getCC(CC cc, int num) {
        //如果你以后看到一个方法的返回值，要一个抽象类 类型，你就返回该抽象类的一个子类对象
        cc.num = num;
        System.out.println(cc.num + "======");//300
        return new Zi();
    }
}

abstract class CC {
    int num = 20;

    public abstract void show(CC cc, int num);

}

class Zi extends CC {
    int num = 200;

    @Override
    public void show(CC cc, int num) {
        this.num = num;
    }
}

接口名作为返回值类型

结论：如果你以后看到一个方法的返回值类型，要一个接口类型，你就返回该接口的一个子类对象

示例：

public class MyTest3 {
    public static void main(String[] args) {
        Iinterface anInterface = getInterface();
        System.out.println(anInterface.num); //200
        System.out.println(Iinterface.num); //200
        System.out.println(Son.num); //200
    }

    private static Iinterface getInterface() {
        //如果你以后看到一个方法的返回值类型，要一个接口类型，你就返回该接口的一个子类对象
        Son son = new Son();
        return son;
    }
}


interface Iinterface {
    public static final int num = 200;

    public abstract void show();
}

class Son implements Iinterface {

    @Override
    public void show() {

    }
}

链式编程

概念：当我调用完一个方法后，如果这个方法会返回一个对象，那我就可以紧接着再去打点，去调用对象中的方法

示例：

public class MyTest {
    public static void main(String[] args) {
        /*
        Student student = new Student();
        Student stu = getStu(student, 20);
        Student student1 = stu.getStudent(student, 2000);
        Student student2 = student1.get(30);*/
        //链式编程:当我调用完一个方法后，这个方法会返回一个对象，那我就可以紧接着再去打点，去调用对象中的方法
        /*
        Student student = new Student();
        Student student1 = student.getStudent(student, 30);
        Student student2 = student1.get(600);*/
        Student student = new Student().getStudent(new Student(), 600).get(1000);
        System.out.println(student.num);//1000
    }

    public static Student getStu(Student student, int num) {
        Student student1 = new Student();
        return student1;
    }
}

class Student {
    int num = 100;

    public Student getStudent(Student student, int num) {
        student.num = num;
        return new Student();
    }

    public Student get(int num) {
        this.num = num;
        return this;
    }
}

java——包的一些概念和理解

package关键字的概述及作用

包的概述：一个包就是一个文件夹
包的作用：用来解决同一个路径下不能存在同名文件的问题(分类管理)，不同包下可以存在相同的文件名（类名），相当于造成了一种隔离的效果，互不影响。
包的划分标准：按照功能、按照模块

包的定义及注意事项

定义包的格式：package 包名;(多级包用.分开即可)
示例：
```
package org.westos.demo4;
```
定义包的注意事项:
a. package语句必须是程序的第一条可执行的代码
b. package语句在一个java文件中只能有一个
c. 如果没有package，默认表示无包名

不同包下类之间的访问

包名：org.westos.demo5

代码示例：

package org.westos.demo5;

public class Demo {
    public static int addMethod(int x,int y){
        return x+y;
    }
}

包名：org.westos.demo6

代码示例：

package org.westos.demo6;
import org.westos.demo5.Demo; //关键步骤：导包

public class Test {
    public static void main(String[] args) {
        int num1 = 10;
        int num2 = 20;
        System.out.println(org.westos.demo5.Demo.addMethod(num1,num2));//30
    }
}

import关键字的概述和使用

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

代码示例：(上面的程序可以用import导包的方法改写，运行机制都是一样的！)

package org.westos.demo6;
import org.westos.demo5.Demo; //关键步骤：导包

public class Test {
    public static void main(String[] args) {
        int num1 = 10;
        int num2 = 20;
        System.out.println(Demo.addMethod(num1,num2));//30
    }
}

注意：这种方式导入是到类的名称，虽然可以最后写*，但是不建议。
即：可以有如下写法：(但不建议这么使用)
```
import org.westos.demo5.*;
```

package,import,class有没有顺序关系(面试题)

首先：先写包名 package
其次：是导包 import
最后：再声明自己写的类 class

面向对象(四种权限修饰符的作用范围)

四种权限修饰符：
1. private(私有的)
2. 默认
3. protected(受保护的)
4. public(公共的)
作用范围：(Y代表被这些权限修饰符修饰后的方法或属性在该范围下能够进行方法，如果为空即表示：无法进行访问)

权限修饰符	本类	同一个包下(子类和无关类)	不同包下(子类)	不同包下(无关类)
private	Y
默认	Y	Y
protected	Y	Y	Y
public	Y	Y	Y	Y

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

修饰符：
a. 权限修饰符：private，默认的，protected，public
b. 状态修饰符：static，final
c. 抽象修饰符：abstract
修饰类的关键字：
a. 权限修饰符：默认修饰符，public
b. 状态修饰符：final
c. 抽象修饰符：abstract
d. 用的最多的就是：public
修饰成员变量的关键字：
a. 权限修饰符：private，默认的，protected，public
b. 状态修饰符：static，final
c. 用的最多的就是：private
修饰构造方法的关键字：
a. 权限修饰符：private，默认的，protected，public
b. 用的最多的就是：public
修饰成员方法的关键字：
a. 权限修饰符：private，默认的，protected，public
b. 状态修饰符：static，final
c. 抽象修饰符：abstract
d. 用的最多的就是：public
除此以外的组合规则：
a. 成员变量：public static final
b. 成员方法：
                      public static
                      public abstract
                      public final