java 通用返回值编码

转载

mob64ca1417eedd 2024-10-22 17:24:39

文章标签 java 通用返回值编码抽象类 System 内部类 文章分类 Java 后端开发

Java语言

面向对象

方法参数类型

类名作为形式参数
一个方法的形参要一个类类型，你就传一个该类的对象

//例如，创建一个Student类，一个setStudent方法（该方法需要一个类类型的形参）
public class MyTest {
    public static void main(String[] args) {
        Student student = new Student();//创建该类的对象
        setStudent(student,100);//传参数为该类的对象
        System.out.println(student.num);//打印结果：100
    }
    private static void setStudent(Student student,int num) {//此方法需要的形参为Student类类型
        student.num=num;
    }
}
class Student{
    int num=20;
}

抽象类名作为形式参数
一个方法的形参要一个 抽象类 类型，你就传一个该抽象类的子类对象

//例如，创建一个Student抽象类，子类为A
public class MyTest {
    public static void main(String[] args) {
        Student student = new A();//创建该抽象类的对象
        setStudent(student, 200);//传参数为该抽象类的对象
        System.out.println(student.num); //打印结果：200
    }
    private static void setStudent(Student student, int num) {
        student.num=num;
    }
}
abstract class Student {
    int num = 10;
    public abstract void show();
}
class A extends Student {
    @Override
    public void show() {
    }
}

接口名作为形式参数
一个方法的形参要一个接口类型，你就传一个该接口的子类对象

//创建一个接口MyInterface，和它的子类B
    public static void main(String[] args) {
        MyInterface bb = new BB();
        setInterface(bb);//穿参数为该接口的子类对象
    }
    public static void setInterface(MyInterface myInterface) {//方法需要的参数类型为接口类型
    }
}
interface MyInterface{
}
class BB implements MyInterface{
}

返回值类型

类名作为返回值类型
一个方法的返回值类型要一个类类型，你返回一个该类对象

//创建一个Teacher类
public class MyTest {
    public static void main(String[] args) {
        Teacher teacher = getTeacher(10);
        System.out.println(teacher.num); //打印结果：10
    }
    public static Teacher getTeacher(int num) {//返回值类型为类类型
        Teacher teacher = new Teacher();
        teacher.num = num;
        return teacher;//返回该类对象
    }
}
class Teacher {
    int num = 20;
}

抽象类名作为返回值类型
一个方法的返回值，要一个 抽象类 类型，你就返回该抽象类的一个子类对象

//创建一个抽象类Fu，子类zi
public class MyTest {
    public static void main(String[] args) {
        Fu fu = getfu(30);
        System.out.println(fu.num);//打印结果：30
    }
    public static Fu getfu(int num) {//返回值类型为抽象类类型
        Zi zi = new Zi();
        zi.num = num;
        return zi;//返回该抽象类的子类对象
    }
}
abstract class Fu {
    int num = 10;
}
class Zi extends Fu {
}

接口名作为返回值类型
一个方法的返回值类型，要一个接口类型，你就返回该接口的一个子类对象

//创建一个接口Interface，和子类A
public class MyTest {
    public static void main(String[] args) {
        getInterface();
    }
    private static Interface getInterface() {//返回值类型为接口类型
        A a = new A();
        return a;//返回值为子类的一个对象
    }
}
interface Interface {
}

class A implements Interface {
}

链式编程

当我们调用完一个方法后，这个方法会返回一个对象，此时我们可以紧接着再去打点，去调用对象中的方法，这就是链式编程。

//例1：
public class MyTest {
    public static void main(String[] args) {
        Student student = new Student().getStudent(new Student(), 600).get(1000);//链式编程
        System.out.println(student.num);//打印结果：1000
    }
}
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;
    }
}

内部类

概述: 把类定义在其他类的内部，这个类就被称为内部类。
例如：在类A中定义了一个类B，类B就是内部类。
内部类访问特点：
a:内部类可以直接访问外部类的成员，包括私有。
b:外部类要访问内部类的成员，必须创建对象。
内部类按照位可分为：
成员内部类：在成员位置定义的类。
局部内部类：在局部位置定义的类。
成员内部类：
如何在测试类中直接访问内部类的成员。
格式: 外部类名.内部类名对象名 = 外部类对象.内部类对象;

//例1：成员内部类的相关问题，要求控制台分别输出30，20，10
public class MyTest {
    public static void main(String[] args) {
        Outer.Inner oi = new Outer().new Inner();//在测试类中直接访问内部类的成员
        oi.show();
    }
}
class Outer {
    public int num = 10;
      class Inner {
        public int num = 20;
        public void show() {
            int num = 30;
            System.out.println(num);//30 
            System.out.println(Inner.this.num);//20 
            System.out.println(Outer.this.num);//10 
        }
    }
}

成员内部类的修饰符：
private：为了保证数据的安全性
static：为了方便访问数据
注意:
a:静态内部类访问的外部类数据必须用静态修饰。
b: 成员方法可以是静态的也可以是非静态的
成员内部类被静态修饰后的访问方式是:
格式: 外部类名.内部类名对象名 = new 外部类名.内部类名();

//例2：内部类被静态修饰符static修饰
public class MyTest {
    public static void main(String[] args) {
        Outer.Inner oi=new Outer.Inner();//成员内部类被静态修饰后的访问方式
        oi.show();
    }
}
class Outer {
    public static int num = 10;
    static class Inner {
        public int num = 20;
        public void show() {
            int num = 30;
            System.out.println(num);//30 num
            System.out.println(Inner.this.num);//20 Inner.this.num
            System.out.println(Outer.num);//10  Outer.this.num
        }
    }
}

局部内部类访问局部变量
a: 可以直接访问外部类的成员
b: 可以创建内部类对象，通过对象调用内部类方法，来使用局部内部类功能
c: 为什么局部内部类访问局部变量必须用final修饰?
答：因为局部变量会随着方法的调用完毕而消失，这个时候，局部对象并没有立马从堆内存中消失，还要使用那个变量；为了让数据还能继续被使用，就用fianl修饰，这样，在堆内存里面存储的其实是一个常量值，JDK1.7之前要加final不然会报错，但是在JDK1.8 不用加也不会报错。

//例3：有关局部内部类访问局部变量的问题
public class MyTest {
    public static void main(String[] args) {
       Outer out = new Outer() ;  // 创建Outer的对象
       out.show() ;// 调用show方法
       /*打印结果为： 
                   10
                   20
      */
    }
}
// 外部类
class Outer {
    private int a = 10 ; // 成员变量
    public void show() {  // 成员方法show
        final int b = 20 ; 定义一个局部变量
        // 局部内部类
        class Inner {
            public void method(){
                System.out.println(a) ;
                System.out.println(b) ;
            }
        }
        Inner i = new Inner() ; // 创建对象
        i.method() ;  // 调用方法
    }
}

匿名内部类

匿名内部类: 就是局部内部类的简化写法。
前提：存在一个类或者接口;这里的类可以是具体类也可以是抽象类。
格式：
new 类名或者接口名(){
重写方法;
} ;
本质：是一个继承了该类或者实现了该接口的子类匿名对象。

//例3：匿名内部类演示
public class MyTest {
    public static void main(String[] args) {
        new AA() {
            @Override
            public void show() {
                System.out.println("重写了抽象类中的show方法1");
            }
        }.show();//打印结果： 重写了抽象类中的show方法1
        
        AA aa=new AA() {//可以用多态的方法，给匿名内部类起名字，通过名字调用
            @Override
            public void show() {
                 System.out.println("重写了抽象类中的show方法2");
                    }
                };
         aa.show();//打印结果： 重写了抽象类中的show方法2
        }
}
abstract class AA{
    public abstract void show();
}

匿名内部类经常用于作为参数传递，或者作为返回值返回

作为参数传递：

//例4：匿名内部类用于作为参数传递
public class MyTest {
    public static void main(String[] args){
        set(new MyClass() {
            @Override
            public void show() {
                System.out.println("匿名内部类作为参数传递");
            }
        });//打印结果：匿名内部类作为参数传递
        MyClass my= new MyClass() {//给匿名内部类起名再作为形参传入
            @Override
            public void show() {
                System.out.println("1111111111111111");
            }
        };
        set(my);//打印结果：1111111111111111
    }
    public static void set(MyClass myClass){
        myClass.show();
    }
}
abstract class MyClass{
    public abstract void show();
}

作为返回值返回

//例5：返回值为抽象类A的匿名内部类、接口B的匿名内部类
public class MyTest {
    public static void main(String[] args) {
        getA().show();
        getB().show2();
    }
    public static A getA() {
        A a = new A() {
            @Override
            public void show() {
                System.out.println("返回值为抽象类A的匿名内部类");
            }
        };
        return a;
    }

    public static B getB(){
        B b= new B(){
            @Override
            public void show2() {
                System.out.println("返回值为接口B的匿名内部类");
            }
        };
        return b;
    }

}
abstract class A {
    public abstract void show();
}
interface B {
    void show2();
}

package关键字

包的概述: 就是文件夹
包的作用: 用来解决同一个路径下不能存在同名文件的问题(分类管理)
包的划分:
按照功能
按照模块
定义包的格式：
package 包名;
多级包用.分开即可
定义包的注意事项：
A:package语句必须是程序的第一条可执行的代码
B:package语句在一个java文件中只能有一个
C:如果没有package，默认表示无包名

import关键字

导包的概述：
不同包下的类之间的访问，我们发现，每次使用不同包下的类的时候，都需要加包的全路径。比较麻烦。这个时候，java就提供了导包的功能
导包格式
import 包名;
注意：这种方式导入是到类的名称。

四种权限修饰符

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

权限修饰符	本类	同一个包下(子类和无关类)	不同包下(子类)	不同包下(无关类)
private	Y
默认	Y	Y
protected	Y	Y	Y
public	Y	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