JAVA中的内部类，以及方法参数类型以及返回值类型问题

最新推荐文章于 2022-12-12 23:11:58 发布

taraex

最新推荐文章于 2022-12-12 23:11:58 发布

阅读量771

点赞数

分类专栏： JAVA

本文链接：https://blog.csdn.net/taraex/article/details/89362704

版权

JAVA 专栏收录该内容

23 篇文章 4 订阅

订阅专栏

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

类名作为形式参数

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

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;
    }

}

结果为100

抽象类名作为形式参数

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

public class MyTest {
    public static void main(String[] args) {
        int num=1;
        Zi zi = new Zi();
       
        set(new Zi(),num);
        zi.show(188);
        System.out.println(zi.num); 
    }

    public static void set(Fu fu,int num){
        fu.num=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;
    }
}

打印 188

接口名作为形式参数

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

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;
    }
}

打印：
10
100
100
100

类名作为返回值类型

如果你以后看到一个方法的返回值类型是一个类类型，你就返回该类的一个对象
例：

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); 
    }

    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;
    }
}

打印：
1
100

抽象类名作为返回值类型

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

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

abstract class Fu {
    int num = 10;
}

class Zi extends Fu {
    public Fu getFu(Fu fu, int num) {
        fu.num = num;
        return this;
    }
}

打印：
109
109

接口名作为返回值类型

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

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); 

        System.out.println(myInterface.NUM);

    }
    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关键字的概述及作用

A:包的概述: 就是文件夹
B:包的作用: 用来解决同一个路径下不能存在同名文件的问题(分类管理)
C:包的划分:
按照功能
按照模块

包的定义及注意事项：
A:定义包的格式
package 包名;
多级包用.分开即可
B:定义包的注意事项
A:package语句必须是程序的第一条可执行的代码
B:package语句在一个java文件中只能有一个
C:如果没有package，默认表示无包名
C:案例演示
包的定义及注意事项

import关键字的概述和使用

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

四种权限修饰符的测试

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

类及其组成所使用的常见修饰符

A:修饰符：
权限修饰符：private，默认的，protected，public
状态修饰符：static，final
抽象修饰符：abstract
B:修饰类的关键字：
权限修饰符：默认修饰符，public
状态修饰符：final
抽象修饰符：abstract

用的最多的就是：public

C：修饰成员变量的关键字：
权限修饰符：private，默认的，protected，public
状态修饰符：static，final

用的最多的就是：private

D:修饰构造方法的关键字：
权限修饰符：private，默认的，protected，public

用的最多的就是：public

E:修饰成员方法的关键字：
权限修饰符：private，默认的，protected，public
状态修饰符：static，final
抽象修饰符：abstract

用的最多的就是：public

F:除此以外的组合规则：
成员变量：public static final
成员方法：public static
public abstract
public final

内部类

内部类概述和访问特点

概述：
把类定义在其他类的内部，这个类就被称为内部类。

特点：
a:内部类可以直接访问外部类的成员，包括私有。
b:外部类要访问内部类的成员，必须创建对象。

内部类分类及成员内部类的直接使用

A:按照内部类位置分类
成员位置:在成员位置定义的类，被称为成员内部类。
局部位置:在局部位置定义的类，被称为局部内部类。
B:成员内部类
如何在测试类中直接访问内部类的成员。
格式: 外部类名.内部类名对象名 = 外部类对象.内部类对象;

成员内部类的常见修饰符及应用

A:成员内部类的修饰符：
private 为了保证数据的安全性
static 为了方便访问数据
注意事项:
a:静态内部类访问的外部类数据必须用静态修饰。
b: 成员方法可以是静态的也可以是非静态的

B:成员内部类被静态修饰后的访问方式是:
格式: 外部类名.内部类名对象名 = new 外部类名.内部类名();

局部内部类访问局部变量的问题

A: 可以直接访问外部类的成员,包括私有
B: 可以创建内部类对象，通过对象调用内部类方法，来使用局部内部类功能
C:局部内部类访问局部变量必须用final修饰
为什么呢?
因为局部变量会随着方法的调用完毕而消失，这个时候，局部对象并没有立马从堆内存中消失，还要使用那个变量。
为了让数据还能继续被使用，就用fianl修饰，这样，在堆内存里面存储的其实是一个常量值。

成员内部类：

class Outer {
    class Inner{
        public void show(){
            System.out.println("这是成员内部类的show方法");
        }
    }
}
class InnerClassDemo {
    public static void main (String[] args) {
        Outer.Inner inner = new Outer().new Inner();
        inner.show();
    }
}

匿名内部类

匿名内部类的格式和理解

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

例题：
按照要求，补齐代码

interface Inter { void show(); }
	class Outer { //补齐代码 }
	class OuterDemo {
		public static void main(String[] args) {
			  Outer.method().show();
		  }
	}

要求在控制台输出”HelloWorld”
补完如下：

interface Inter {
    void show();
}

class Outer {
    public static Inter method(){
        return new Inter() {
            @Override
            public void show() {
                System.out.println("HelloWorld");
            }
        };
    }

    }
    class OuterDemo {
        public static void main(String[] args) {
            Outer.method().show();
        }
    }

类中定义接口

概述：
在一个类中可以定义一个接口
例：

	public class Mytest {
    public static void main(String[] args) {
        Outer outer = new Outer();
        outer.method();
    }
}
class Outer{
    interface Inner{
        void show();
    }
    public  void method(){
        new Inner(){
            @Override
            public void show() {
                System.out.println("重写了接口中的show方法");
            }
        }.show();
    }
}

总结：主要学习了方法参数类型以及返回值类型问题，还有内部类，以及匿名内部类的运用。

taraex

关注

0
点赞
踩
1

收藏

觉得还不错? 一键收藏
0
评论
JAVA中的内部类，以及方法参数类型以及返回值类型问题

方法参数类型以及返回值类型问题类名作为形式参数如果你以后看到一个方法的形参要一个类类型，你就传一个该类的对象例：public class MyTest { public static void main(String[] args) { Student student = new Student(); int num=2; set(...
复制链接

扫一扫