参数和返回值、四种权限修饰符

已于 2022-02-17 17:40:13 修改
阅读量283 收藏
点赞数
分类专栏： Java基础 文章标签： p2p linq wpf
于 2022-01-13 21:14:21 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_56930747/article/details/122482761
版权

目录

一、方法参数和返回值

二、链式编程

三、包

四、四种权限修饰符

五、内部类

一、方法参数和返回值

  1. 类名作为形式参数传递

    Student类：

     public class Student {
     int age;
     String name;
 ​
     public Student(int age, String name) {
         this.age = age;
         this.name = name;
     }
 ​
     public void show(Student student) {
         System.out.println("年龄：" + student.age + "; 名字：" + student.name);
     }
 }

    测试类Test:

     public class Test1 {
     public static void main(String[] args) {
         Student student = new Student(20,"Alice");
         student.show(student);
     }
 }

    从这段代码我们可以看出，类名可以作为参数进行传递，而这时传递的就是一个实例化的对象。

  2. 抽象类名作为形参传递

    抽象父类Animal:

     public abstract class Animal {
     int age;
     String name;
     abstract void show(Animal animal);
 ​
     public Animal(int age, String name) {
         this.age = age;
         this.name = name;
     }
 }

    子类Cat:

     public class Cat extends Animal {
     public Cat(int age, String name) {
         super(age, name);
     }
 ​
     @Override
     void show(Animal animal) {
         System.out.println("年龄：" + animal.age + "; 名字：" + animal.name);
     }
 }

    测试类Test：

     public class Test2 {
     public static void main(String[] args) {
         Animal cat = new Cat(2, "Jack");
         cat.show(cat);
     }
 }

    这个例子中我们发现如果需要一个抽象类类型的形参，那么就可以传递一个该类的子类对象。

  3. 接口名作为形参

    定义的接口MyInterface：

     public interface MyInterface {
     int age = 20;
     void show(MyInterface myInterface);
 }

    Student类：

     public class Student implements MyInterface {
     int age = MyInterface.age;
     String name;
 ​
     public Student(String name) {
         this.name = name;
     }
 ​
     public Student(int age, String name) {
         this.age = age;
         this.name = name;
     }
 ​
     @Override
     public void show(MyInterface myInterface) {
         System.out.println("age:" + age + ";name:" + name);
     }
 }

    测试类Test:

     public class Test {
     public static void main(String[] args) {
         MyInterface student = new Student("Alice");
         student.show(student);
     }
 }

    这个例子我们可以知道，如果形参为接口类型，那么我们可以传递一个该接口的子类对象。

二、链式编程

  1. 什么是链式编程

    链式编程是一种代码编写风格。

    比如调用了一个方法，该方法返回的类型是对象，那么直接可以在后面加上 . 来继续调用该对象的方法。

  2. 例子

    Student类：

    public class Student {
    int age = 20;
    String name = "Alice";

    public int getAge() {
        return age;
    }

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

    测试类Test:

    public class Test {
    public static void main(String[] args) {
        //链式编程
        int age = new Student().getStudent(new Student(), 18).getAge();
        System.out.println(age);
        //常规编程
        Student student = new Student();
        Student student1 = new Student();
        student = student.getStudent(student1, 18);
        int age1 = student.getAge();
        System.out.println(age1);
    }
}

    如上所示，我给出了两种代码风格，明显链式编程简化了代码，提高了效率。

三、包

  1. 包的定义

    包定义的格式： package 包名;

    多级包之间可以用 . 分开。

  2. package关键字

    注意事项：

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

  3. import关键字

    import关键字是Java为我们提供的导包的方式。

    格式:

    import 包名;

    注意：这种方式导入是到类的名称；

    虽然最后可以写*，但是不建议。

四、四种权限修饰符

本类同一包下（子类和无关类）不同包下（子类）不同包下（无关类）
private√
缺省（默认）√√
protected√√√
public√√√√

  1. 各种修饰符

权限修饰符：private,缺省,protected,public
状态修饰符：static,final
抽象修饰符：abstract

      2.修饰类的关键字

权限修饰符：默认修饰符,public
状态修饰符：final
抽象修饰符：abstract

        3.修饰成员变量的关键字

权限修饰符：private,缺省,protected,public
状态修饰符：static,final

        4.修饰构造方法的关键字

权限修饰符：private,缺省,protected,public

        5.修饰成员方法的关键字

权限修饰符：private,缺省,protected,public
状态修饰符：static,final
抽象修饰符：abstract

五、内部类

  1. 内部类概述

    定义在其他类内部的类，这个类称为内部类。

    例如：在类A中定义了一个类B，那么类B就是内部类。

    例子：

    public class NeiBuLei {
    public class Nei{
        //内部类
    }
}

  2. 内部类的访问特点

    内部类可以直接访问外部类的成员，包括私有；
外部类要访问内部类的成员必须创建对象。

    例如：

    内部类访问外部类成员：

    public class Wai {
    private int age = 20;

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

    public class Nei {
        public int num = 100;

        public void printAge() {
            System.out.println("age:" + age);
        }

        public void getShow() {
            show();
        }
    }
}
//测试类Test
public class Test {
    public static void main(String[] args) {
        Wai.Nei nei = new Wai().new Nei();
        nei.getShow();
        nei.printAge();
    }
}

    外部类访问内部类成员：

    public class Wai {

    public class Nei {
        public int num = 100;

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

    public void getShow() {
        Nei nei = new Nei();
        nei.show();
    }

    public void printNum() {
        Nei nei = new Nei();
        System.out.println(nei.num);
    }
}
//测试类Test
public class Test {
    public static void main(String[] args) {
        Wai wai = new Wai();
        wai.getShow();
        wai.printNum();
    }
}

  3. 内部类按照位置的分类

    成员内部类：定义在成员位置；

    局部内部类：定义在局部位置。

    成员内部类：

    public class Wai {

    public class Nei {
        public int num = 100;
        public void show() {
            System.out.println("内部类的show方法");
        }
    }
}

    局部内部类：

    public class Wai {
    public void show(){
        class Nei{
            int age=10;
            public void neiShow(){
                System.out.println("局部内部类的show方法");
            }
        }
    }
}

  4. 成员内部类如何在测试类中直接访问内部类的成员

    格式：外部类名.内部类名 对象名 = 外部类对象.内部类对象;

    例如：

    //成员内部类
public class Wai {

    public class Nei {
        public int num = 100;
        public void show() {
            System.out.println("内部类的show方法");
        }
    }
}
//测试类Test
public class Wai {

    public class Nei {
        public int num = 100;
        public void show() {
            System.out.println("内部类的show方法");
        }
    }
}

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

    成员内部类的修饰符：

    private:为了保证数据的安全性

    static:为了方便访问数据

    注意事项：

    a.静态内部类访问的外部类数据必须用静态修饰；

    b.成员方法可以是静态的也可以是非静态的。

    成员内部类被静态修饰后的访问方式是：

    格式：
外部类名.内部类名 对象名=new 外部类名.内部类名();

    例如：

    //定义的成员内部类
public class Wai {
    static String str="Hello";
    public static class Nei {
        int num = 100;
        public void show() {
            System.out.println(str);
        }
    }
}
//测试类
public class Test2 {
    public static void main(String[] args) {
        Wai.Nei nei = new Wai.Nei();
        nei.show();
    }
}

  6. 局部内部类访问局部变量

    访问方式：

    1. 直接访问外部类成员；
2. 创建内部类对象，通过对象调用内部类的方法，来使用局部内部类的功能；

    注意事项： 局部内部类访问局部变量必须用final修饰。

  7. 匿名内部类

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

    例如：

    //Student类
public class Student {
    int age = 20;
    String name = "Alice";
    public void show(){
        System.out.println("Student的show方法");
    }
}

public class Test {
    public static void main(String[] args) {
        Student student = new Student() {//匿名内部类
            @Override
            public void show() {
                System.out.println("重写的show方法");
            }
        };
        student.show();
    }
}

    匿名类中的this关键字代表的是匿名内部类。

大雾肆起
关注
专栏目录
Java学习：JUnit单元测试
Java慢热型混子选手
01-25 166
JUnit单元测试 学习目标 能够使用Junit进行单元测试 Junit的概念 概述 : Junit是Java语言编写的第三方单元测试框架(工具类) 作用 : 用来做“单元测试”——针对某个普通方法，可以像main()方法一样独立运行，它专门用于测试某个方法。 Junit的使用步骤 1.在模块下创建lib文件夹,把Junit的jar包复制到lib文件夹中 2.选中Junit的jar包,右键选中 add as Library,把JUnit4的jar包添加到classPath中 3.在测试
Java基础（10）接口、方法的参数类型以及返回值类型、权限修饰符
nswzr的博客
04-22 1578
1.接口 1. 接口的由来：为了体现事物功能的扩展性，Java通过接口来定义这些额外的扩展功能。但是并不给出具体实现，需要类来重写 2. 接口的特点 （1）定义接口：interface 定义格式：interface 接口名{} （2）实现类：implements 定义格式：class 类名 implements 接口名{} （3）接口不能实例化，需要按照多态的方式实例化 （4）接口的实现类：具体类...
java——测试权限修饰符
xxf15162161455的博客
05-17 472
测试权限修饰符1.public 公开的2.protected 受保护的3.default 默认的 就是不添加修饰符4.private 私有的，只能本类访问         本类,  同包类,  同包子类,  不同包子类, 不同包的类 public    能      能   能      能        能 protected 能      能      能         能        ...
java测试四种不同的权限修饰符
Meloneating的博客
02-08 327
测试四种权限修饰符测试private测试protected和default测试public 文章内容选自尚硅谷 以前的内容没有讲解完全，现在补上，链接为 java的四种权限修饰符. 测试private private是类封装性的重要体现，在java中，私有方法和属性只能在类的内部调用 先在com.atguigu.java2包内创建一个Order的类 package com.atguigu.java2; public class Order { private int orderPrivate; in
new Child();new Child(1);
mischen520的博客
08-09 555
/** * */ package com.mischen.cn; /** * @author mischen * */ public class Child extends Parent{ private Child(){ this(1); System.out.print("B"); } protected Child(int i){
C#高级--特性详解
热门推荐
李宥的博客
08-02 1万+
C#高级–特性详解 一、什么是特性 1、特性定义 **特性（Attribute）**是用于在运行时传递程序中各种元素（比如类、方法、结构、枚举、组件等）的行为信息的声明性标签。您可以通过使用特性向程序添加声明性信息。一个声明性标签是通过放置在它所应用的元素前面的方括号（[ ]）来描述的。 特性（Attribute）用于添加元数据，如编译器指令和注释、描述、方法、类等其他信息。.Net 框架提供了两种类型的特性：预定义特性和自定义特性。 2、特性的语法 特性（Attribute）的名称和值是在方括号内规定的，
Java基础——方法参数类型与返回值类型、权限修饰符、内部类、匿名内部类
威威的博客
11-07 771
1.方法参数类型与返回值类型 类名作为参数传递：当看到一个方法的形参需要一个类 类型时，就传递该类的对象。 抽象类名作为参数传递：当看到一个方法的形参需要一个抽象类 类型时，就传递该抽象类的子类对象。 接口名作为参数传递：当看到一个方法的形参需要一个接口 类型时，就传递一个该接口的子类对象。 类名作为返回值类型：当看到一个方法的返回值类型是一个类 类型时，就返回一个该类的对象。 抽象类名作返回值类型：当看到一个方法的返回值类型是一个抽象类 类型时，就返回一个该抽象类的子类对象。 接口名作为返回值类
java构造方法没有权限修饰符,java_day08_权限修饰符和构造方法
weixin_42360972的博客
03-22 906
面向对象--方法一,权限修饰符1,四个权限修饰符public protected default private2,在java中访问其他类的属性/方法1),自己能否访问2),同一个包下的其他类能否访问3),子类能否访问4),任何类能否访问publicprotecteddefaultprivate任何类✔️×××子类✔️✔️××同包✔️✔️✔️×自己✔️✔️✔️✔️3,关键字this:调用该方...
方法参数类型以及返回值类型和权限修饰符以及类部类
weixin_43529853的博客
12-19 146
方法参数类型及返回值类型,修饰符，内部类
fxh0607的博客
12-02 442
方法参数类型及返回值类型 类名作为形式参数 ​ 一个方法的形参要一个 类 类型，你就传递一个该类的对象 抽象类名作为形式参数 ​ 一个方法的形参要一个抽象类 类型，你就传递一个该抽象类的子类对象 接口名作为形式参数 ​ 一个方法的形参要一个接口 类型，你就传递一个该接口的子类对象 类名作为返回值 ​ 一个方法的返回值类型是一个类 类型，你就返回一个该类的对象 抽象类名作为返回值类型 ​ 一个方法的返回值类型是一个抽象类 类型，你就返回一个该抽象类的子类对象 接口名作为返回值类型 ​
继承（特点、构造方法、权限修饰符、）
weixin_44216665的博客
07-07 272
特点（成员变量、方法、构造方法）、构造方法、权限修饰符、
05【继承、抽象、权限修饰符、final】
緑水長流*z
07-30 4712
一、继承 1.1 继承概述 继承是面向对象三大特征之一，继承就是子类继承父类的特征（属性）和行为，使得子类对象（实例）具有父类的属性和方法，或子类从父类继承方法，使得子类具有父类相同的行为。 继承可以使得子类别具有父类别的各种属性和方法，而不需要再次编写相同的代码。在令子类别继承父类别的同时，可以重新定义某些属性，并重写某些方法，即覆盖父类别的原有属性和方法，使其获得与父类别不同的功能。另外，为子类别追加新的属性和方法也是常见的做法。 总结： 1）子类继
访问权限修饰符与方法的重写
SR0101020321的博客
03-21 1264
访问权限修饰符 作用：表示被修饰的元素的访问权限 访问权限修饰符有四个：public protected 【default】(又叫默认权限修饰符) private 访问权限修饰符可以修饰的元素： 1.类 只有public abstract和final能够修饰，或者不加【private和protected可以修饰内部类】 ​ 2.成员变量 ​ 3.成员方法 四个修饰符的特点 1. public修饰的成员一切类可见 2. protected修饰的成员本包下面可见，不同包下只有子类可见 3. 默认修
形式参数和返回值的学习总结
weixin_52769303的博客
05-14 142
形式参数和返回值问题的研究 package 权限修饰符的应用范围
P2P 网络 简单研究 1
waterHBO的博客
10-14 1067
P2P（Peer-to-Peer）网络是一种分布式网络架构，其中所有节点（即网络中的计算机或设备）作为对等节点（peers），既可以作为客户端请求资源，也可以作为服务器向其他节点提供资源。与传统的客户端-服务器架构不同，P2P网络没有中央服务器或单一控制点，所有参与的节点都有相同的地位。
Springboot集成Kafka
weixin_44825912的博客
10-15 509
我们使用spring本身支持的spring-kafka依赖，但是需要注意版本问题，不同的springboot版本支持不同的kafka版本，避免因版本不同带来困扰！参考下图：
【ROS2实操五】通信机制补充
最新发布
qq_68192341的博客
10-15 1108
本章主要介绍关于通信机制的补充内容，比如：分布式框架搭建、重名问题处理、常用API、通信机制工具等等，这些补充内容的知识点比较零散但是每个知识点都不复杂。学习内容学习收获1.分布式通信的概念、应用场景以及通信规则。能够独立搭建分布式通信框架。2.不同工作空间功能包重名时可能会出现的问题。以后要尽力避免功能包重名的情况。3.元功能包的概念、应用场景以及创建规则。能够自定义元功能包。4.节点重名时遇到的问题以及处理方式。可以以合适的方式解决节点重名问题。5.话题重名时遇到的问题以及处理方式。
Spring集成Redisson及存取几种基本类型数据
LoveTalk的博客
10-14 916
在Spring boot中使用Redisson存取几种类型的方法(多种方法实现,附带区别讲解)
DevExpress WPF中文教程：Data Grid（数据网格）实现细节一览
需要界面开发、IDE工具研发中文教程资料的小伙伴，记得私信我~
10-15 1252
本文主要介绍如何解决使用DevExpress WPF的数据网格组件实现细节一览，欢迎下载最新版组件体验！
C#类修饰符详解与实践指南
C#类修饰符是编程中用来定义类的访问权限、抽象特性和生命周期的关键元素，对于理解和构建高效、可维护的C#代码至关重要。本文档将全面概述C#中的各类修饰符，适合C#初学者和开发者查阅。 1. **公共修饰符 (Public)...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值