JAVA面向对象之内部类与方法参数类型及返回值类型

已于 2022-04-16 18:36:07 修改
阅读量1.2k 收藏 2
点赞数 1
分类专栏： JavaSE 文章标签： java
于 2022-04-15 19:23:04 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_48622530/article/details/124201890
版权

JAVA面向对象之内部类与方法参数类型及返回值类型

文章目录

1.内部类

内部类将一个类A定义到另一个类B的内部，那么类A叫做，内部类类B叫做外部类根据内部类在外部类中定义的位置不同，分为成员内部类和局部内部类；

成员内部类：定义在外部类的成员位置

局部内部类：定义在外部类的局部位置，也就是外部类中的方法内部

public class MyTest {
    public static void main(String[] args) {
   
    }
}

class B {
    //成员内部类
    class A {

    }

    public void show() {
        //局部内部类
        class C {

        }
    }

}

1.2创建成员内部类的对象语法：

外部类名.内部类名 对像名=外部类对象.内部类对象

外部类不可私有修饰

public class Wai {
    int num = 20;
    private int a = 60;

    //成员内部类
    public class Nei {
        int n = 5;
        int x = 100;

        public void neiShow() {
            System.out.println("内部类的show方法" + n);
            //内部类的特点：内部类可以直接访问外部类的成员，包括私有成员。
            System.out.println(num);
            System.out.println(a);
            waiShow();
            hehe();
        }

        public void neiHeHe() {
            System.out.println("内部类hehe方法");
        }
    }

    public void waiShow() {
        System.out.println("外部类的show方法");
    }

    private void hehe() {
        System.out.println("外部类的私有方法");
    }

    public void test() {
        //创建内部类对象
        Nei nei = new Nei();
        System.out.println(nei.n);
        System.out.println(nei.x);
        nei.neiHeHe();
    }
}

public class MyTest2 {
    public static void main(String[] args) {
        //在测试类里面，调用内部类的方法
        //创建成员内部类的对象的语法如下：格式: 	外部类名.内部类名 对象名 = 外部类对象.内部类对象;
        Wai.Nei nei = new Wai().new Nei();
        nei.neiShow();
        System.out.println("====================================");
        //内部类的特点：内部类可以直接访问外部类的成员，包括私有成员。

        Wai wai = new Wai();
        wai.test();
    }
}

/*输出
内部类的show方法5
20
60
外部类的show方法
外部类的私有方法
====================================
5
100
内部类hehe方法
*/

1.3内部类可以私有修饰，私有的成员内部类，外界就无法创建其对象

public class MyTest {
    public static void main(String[] args) {
        //私有的成员内部类，外界就无法创建其对象了
        //Outer.Inner inner = new Outer().new Inner();
        //inner.neiShow();

        Outer outer = new Outer();
        outer.waiShow();
    }
}

class Outer {
    //内部类可以私有修饰
    private class Inner {
        public void neiShow() {
            System.out.println("nei show");
        }
    }

    public void waiShow() {
        Inner inner = new Inner();
        inner.neiShow();
    }

1.3static也可以修饰内部类

静态的成员内部类 创建语法更加简介：Wai.Nei nei=new wai.nei()

静态的成员内部类，只能访问外部类的静态成员

public class Wai {
    static int num = 100;

    //static 也可以修饰内部类
    public static class Nei {
        public void neiShow() {
            //静态的成员内部类,只能访问外部类的静态成员。
            System.out.println(num);
        }
    }
    
    
public class MyTest {
    public static void main(String[] args) {
        //静态的成员内部类，创建对象的语法
        Wai.Nei nei = new Wai.Nei();
    }
}

1.4访问 外部类名.this.num

class InnerClassTest {
    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(this.num); //20

            System.out.println(Inner.this.num); //20
            //这样太繁琐了
            //System.out.println(new Outer().num); //10
            // 这个语法 Outer.this 表示外部类对象
            System.out.println(Outer.this.num);
            	}
         }
}

1.5局部内部类，要访问外部类的局部变量，必须用final修饰，使之成为常量

public class MyTest2 {

}

class Outer {
    public void waiShow(final int a) {
        //局部变量
        final int num = 20; //JDK1.8 之后，这个final默认就加上了，JDK1.8之前必须手动加上。

        /*
        *    为什么呢?
  	因为局部变量会随着方法的调用完毕而消失，这个时候，局部对象并没有立马从堆内存中消失，还要使用那个变量。
	为了让数据还能继续被使用，就用final修饰，这样，在堆内存里面存储的其实是一个常量值。
	JDK1.8之后，final会默认加上，你不用手动去加，但是你要知道
        * */
        //定义局部内部类
        class Inner {
            public void neiShow() {
                //Variable 'num' is accessed from within inner class, needs to be final or effectively final
                //局部内部类，要访问外部类的局部变量，局部变量，必须用final修饰，使之成为常量
                //num = 120; 报错，他是常量
                System.out.println(num);
                System.out.println(a);
            }
        }
    }
}

1.6外部类访问内部类里面的成员方法

需要在外部类的方法中，创建内部类对象，然后用对象去调用

public class MyTest2 {
    public static void main(String[] args) {
        Wai wai = new Wai();
        wai.test();
    }
}


public class Wai {
    int num = 20;
    private int a = 60;

    //成员内部类
    public class Nei {
        int n = 5;
        int x = 100;

        public void neiShow() {
            System.out.println("内部类的show方法" + n);
            //内部类的特点：内部类可以直接访问外部类的成员，包括私有成员。
            System.out.println(num);
            System.out.println(a);
            waiShow();
            hehe();
        }

        public void neiHeHe() {
            System.out.println("内部类hehe方法");
        }
    }

    public void waiShow() {
        System.out.println("外部类的show方法");
    }

    private void hehe() {
        System.out.println("外部类的私有方法");
    }

    public void test() {
        //创建内部类对象
        Nei nei = new Nei();
        System.out.println(nei.n);
        System.out.println(nei.x);
        nei.neiHeHe();
    }
}

2.面向对象之(方法参数类型以及返回值类型)

  • 类名作为形参参数
//当你以后看到一个方法的形参，要一个类 类型，就传递一该类的参数
public class MyTest {
    public static void main(String[] args) {
        int num = 20;
        Student student = new Student();
        student.num = 50;
         //基本类型作为参数传递：属于值传递，传递的是值，形参的改变，不影响实参。
        //引用类型作为参数传递：属于引用传递，传递的是地址值，形参的改变会影响实参。
        test(student, num);//20
        student.show(new Student(), 80);
        System.out.println(student.num); //20
    }

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

class Student {
    int num = 100;

    public void show(Student studnet, int num) {
        studnet.num = num;
    }
}
  • 抽象类名作为形式参数
 //当你以后看到一个方法的形参，要一个 抽象类 类型，你就传递一个该抽象类的子类对象。 说白了，就是多态
public class MyTest {
    public static void main(String[] args) {
      
        //多态形式
        AA aa = new BB();
        aa.num = 88;
        test(aa, 2);
        System.out.println(aa.num); //2
    }

    public static void test(AA aa, int num) { //AA aa=bb 多态
        //多态形式访问成员变量，编译看左边，运行也看左边。
        aa.num = num;
    }
}

abstract class AA {
    int num = 100;

    public abstract void aa(int num);
}

class BB extends AA {
    int num = 30;

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

//#####################################################################################
public class MyTest1 {
    public static void main(String[] args) {
      
        //多态形式
       BB bb = new BB();
        aa.num = 88;
        test(bb, 2);
        System.out.println(bb.num); //88
    }

    public static void test(AA1 aa, int num) { //AA aa=bb 多态
        //多态形式访问成员变量，编译看左边，运行也看左边。
        aa.num = num;
    }
}

abstract class AA1 {
    int num = 100;

    public abstract void aa(int num);
}

class BB extends AA1 {
    int num = 30;

    @Override
    public void aa(int num) {
        this.num = num;
    }
}
  • 接口名作为形式参数
  //当你以后看到一个方法的形参要一个 接口 类型，你就传递一个该接口的实现类的对象。
public class MyTest {
    public static void main(String[] args) {
        DD dd = new DD();
        test(dd);
        System.out.println(dd.num);
        System.out.println(MyInterface.num);
    }

    public static void test(MyInterface myInterface) { //  MyInterface myInterface = dd  多态
        System.out.println(myInterface.num);
    }
}

interface MyInterface {
    public static final int num = 100;

    void show();
}

class DD implements MyInterface {
    @Override
    public void show() {
        System.out.println(this.num);
    }
}
  • 类名作为返回值
//如果你以后看到一个方法的返回值类型，是一个类 类型，你就返回该类的对象。
public class MyTest {
    public static void main(String[] args) {
        Student student = getStudent(10);
        student.num = 555;
        Student s2= student.test(89);
        System.out.println(student.num); //89
        System.out.println(s2.num); //89
 
        System.out.println(s2==student);
    }
    public static Student getStudent(int num) {
        Student student = new Student();
        student.num = num;
        return student;
    }
}
class Student {
    int num = 20;
    public Student test(int a) {
        this.num = a;
        return this; //this 代表一个该类的引用，哪个对象调用这个方法，方法中的this 就代表谁
    }
  • 抽象类名作为返回值类型
//如果以后你看到一个方法的返回值类型，要一个抽象类 类型，你就返回该抽象类的子类对象。
public class MyTest {
    public static void main(String[] args) {
        AA aa = test();
        //多态形式，访问成员变量，编译看左边，运行也看左边。
        System.out.println(aa.num);//200
        //向下转型
        BB bb = (BB) aa;
        System.out.println(bb.num); //77
    }

    public static AA test() {
        BB bb = new BB();
        bb.num = 77;
        return bb;
    }
}

abstract class AA {
    int num = 200;

    public abstract void aa();
}

class BB extends AA {
    int num = 500;

    @Override
    public void aa() {
        this.num = 90;
    }
}
  • 接口名作为返回值类型
//如果你以后看到一个方法的返回值类型，要一个接口类型，你就返回一个该接口的实现类对象。
public class MyTest {

    public static void main(String[] args) {
        MyInterface myInterface = test();  // MyInterface myInterface=ee 多态
        System.out.println(myInterface.num);//100

        //向下转型。
        EE ee = (EE) myInterface;
        System.out.println(ee.num); //88


    }

    public static MyInterface test() {
        EE ee = new EE();
        ee.num = 88;
        return ee;
    }
}

interface MyInterface {
    int num = 100;

}

class EE implements MyInterface {
    int num = 600;
}

总结: ①当你以后看到一个方法的形参，要一个类 类型，就传递一该类的参数

​ ②当你以后看到一个方法的形参，要一个 抽象类 类型，你就传递一个该抽象类的子类对象。 说白了，就是多态

​ ③当你以后看到一个方法的形参要一个 接口 类型，你就传递一个该接口的实现类的对象。

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

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

​ ⑥如果你以后看到一个方法的返回值类型，要一个接口类型，你就返回一个该接口的实现类对象。

代码不会头发来凑
关注
  • 1
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Java中接口作为方法的返回值类型和参数类型使用
weixin_46136516的博客
08-16 3593
题目需求是定义一个学生类，在测试类中给出一个方法，可以比较两个学生谁的年龄更大。 往常我的做法会是： //定义一个Student类 class Student{ String name; int age; } //测试类 class TestStudent{ public static void main(String[] args){ //创建两个学生对象 Student s1 = new Student(); s1.age = 2
js 内置对象的方法
weixin_60200454的博客
08-26 512
Array类型 Array 对象属性 1、length 设置或返回数组中元素的数目。 length是Array的实例属性。返回或设置一个数组中的元素个数。该值是一个无符号 32-bit 整数，并且总是大于数组最高项的下标。 2、prototype 通过数组的原型对象可以为所有数组对象添加属性。 Array 对象方法 1、concat() concat()方法用于合并两个或多个数组。此方法不会更改现有数组，而是返回一个新数组。 如果要进行 concat() 操作的参数是数组，那么添..
Java中不同类型变量作为方法参数，其值是否改变问题
我的代码世界
09-24 1013
1、基本数据类型做方法的参数：基本类型传递的是该变量的值（值传递），无论方法对该值如何修改，都不会影响外部的变量。 public class Demo1{ public static void main(String []args) { int i=10; System.out.println(i); //10 method(i); //基本类型作为方法的参数 System.out.println(i); //10 } public static void met
java 内部类 参数_java内部类原理与用法详解
weixin_39640687的博客
02-16 509
本文实例讲述了java内部类原理与用法。分享给大家供大家参考，具体如下：概念内部类：可以包含在另外一个类中的类外部类：包含内部类的类每个内部类都会被编译为一个独立的类，生成一个独立的字节码文件。内部类可以方便地访问外部类的私有变量，内部类也可以声明为private从而实现对外完全隐藏。分类java中的四种内部类(根据定义的位置和方式划分)-静态内部类-成员内部类-方法内部类-匿名内部类分类介绍-静...
JS基础之函数内部对象、属性、方法
weixin_38203203的博客
01-14 2213
在函数内部，有2个特殊的对象：arguments 和 this。 · arguments：类数组对象，包含着传入函数中的所有参数。     >这个对象还有一个名叫callee属性，指向拥有这个arguments对象的函数。---经常用于递归     >另一个函数对象的属性，caller，保存着调用当前函数的函数的引用，如果是在全局作用域中调用当前函数，它的值为null · this：引用的
Java面向对象（基础）- 类的成员之三：构造器(Constructor)
最新发布
10-24
【Java面向对象（基础）- 类的成员之三：构造器(Constructor)】 构造器是Java中用于初始化新创建对象的特殊方法。当我们使用`new`关键字创建一个对象时，构造器会被自动调用，用于设置对象的初始状态。构造器的名字...
JAVA面向对象编程测试题.docx
11-10
以上是针对JAVA面向对象编程测试题的部分解析，涵盖了变量作用域、方法声明、构造方法、访问控制、方法重载、接口定义等核心概念。实际考试中，考生还需要理解类的继承、多态、封装等面向对象编程的关键特性。
浅谈java面向对象(类,封装,this,构造方法)
08-30
浅谈java面向对象(类,封装,this,构造方法) 面向对象编程是一种编程范式，强调使用对象和类来解决问题。 Java 是一种面向对象的编程语言，它提供了多种机制来支持面向对象编程，如类、对象、继承、多态、封装等。 ...
14_Java面向对象_第6天（Eclipse高级、类与接口作为参数返回值）_讲义
02-16
本讲义主要聚焦于Eclipse的高级用法以及在Java中如何使用类与接口作为参数和返回值，这对于理解和提升Java编程能力至关重要。 1. **Eclipse高级特性** - **代码自动完成**：Eclipse的智能提示功能可以帮助开发者...
Java面向对象程序设计期末考试练习题及答案
12-06
【Java面向对象程序设计知识点详解】 1. 可移植性：Java 语言的可移植性是其重要特性之一，体现在它的“一次编写，到处运行”（Write Once, Run Anywhere, WORA）的理念上。这得益于Java虚拟机（JVM），它确保了...
对象内部方法的创建和使用
weixin_30852451的博客
10-11 122
使用以下语法创建对象方法： methodName : function() { code lines } 使用以下语法访问对象方法： objectName.methodName() 通常 fullName() 是作为 person 对象的一个方法， fullName 是作为一个属性。 转载于:https://www.cnblogs.com/halao/p/765195...
Java 面向对象4——抽象类、接口与内部类及参数传递
weixin_57807561的博客
09-26 783
Java 面向对象4——抽象类、接口与内部类及参数传递 1）抽象类 2）接口 3）接口与抽象类区别 4）内部类 5）参数传递
java字符类型的返回值_SSM框架之SpringMVC（4）返回值类型及响应数据类型
weixin_42168230的博客
02-27 446
SpringMVC(4)返回值类型及响应数据类型1. 返回值分类1.1. 返回字符串Controller方法返回字符串可以指定逻辑视图的名称，根据视图解析器为物理视图的地址。@RequestMapping(value="/hello")public String sayHello() {System.out.println("Hello SpringMVC!!");// 跳转到XX页面return...
Java-方法参数类型以及返回值类型讨论
PreyHard的博客
10-20 7969
一.类名作为形式参数。 当类名作为形式参数时，那你就传一个该类的对象，或者直接传一个匿名对象new 类名()。 二.抽象类名作为形式参数 当抽象类名作为形式参数时，那你就传一个该类的子类对象。或者传一个该接口子类匿名对象 三.接口作为形式参数。 当接口作为形式参数时，那你就传一个该接口的子类对象，或者直接传一个该接口子类匿名对象new 类名()。 四.方法中类名作为返回值类型（返...
java中向匿名内部类传递参数
热门推荐
samyang1的博客
06-01 1万+
目的：将innerString变量值传给匿名内部类解决方案：在匿名内部类里定义一个方法，在创建匿名内部类对象时调用自定义方法进行传参。具体见代码：jb.addActionListener(new ActionListener(){ private String innerStr; @Override public void a...
Java基础day12
原文的博客
08-15 159
Java基础day12Java基础部分day12-内部类&常用API1. 参数传递1.1 类名作为形参和返回值1.2 抽象类作为形参和返回值1.3 接口名作为形参和返回值2. 内部类2.1 内部类的基本使用2.2 成员内部类2.3 局部内部类2.4 匿名内部类2.4 匿名内部类在开发中的使用3. 常用API3.1 Math3.2 System3.3 Object类的toString方法3.4 Object类的equals方法3.5 冒泡排序原理3.6 冒泡排序代码实现3.7 Arrays Java基
java类方法中使用内部类的参数问题
maidaogo的专栏
10-23 3078
1.问题： public class Test{ private int a = 1; static int b = 2; public void method(){ final int c = 3; int d = 4; class Cinner { public void mymethod(){ //Here a、b、c、d哪些参数可以调用 }
java中的内部类创建对象方法
每天进步一点点
07-05 1228
public class A {               public class B {                           public void hxy() {             System.out.println("hxy");         }     }           public static void ma
Java面向对象：类与对象、包的概念解析
- **构造方法**：构造方法是与类同名且没有返回值的方法，用于初始化新创建的对象。例如，`Car`类的构造方法没有具体实现，但它是存在的。 - **封装**、**继承**和**多态性**：这是面向对象编程的三大特性。封装...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值