Java语言（面向对象4（方法参数类型、返回值类型、内部类、匿名内部类、package、import关键字、权限修饰符））

最新推荐文章于 2024-07-30 21:43:27 发布
最新推荐文章于 2024-07-30 21:43:27 发布
阅读量203 收藏
点赞数
分类专栏： JavaSE
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_45677119/article/details/102658917
版权

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;
    }
}
内部类
  1. 概述: 把类定义在其他类的内部，这个类就被称为内部类。
    例如：在类A中定义了一个类B，类B就是内部类。
  2. 内部类访问特点：
    a:内部类可以直接访问外部类的成员，包括私有。
    b:外部类要访问内部类的成员，必须创建对象。
  3. 内部类按照位可分为：
    成员内部类：在成员位置定义的类。
    局部内部类：在局部位置定义的类。
  4. 成员内部类：
    如何在测试类中直接访问内部类的成员。
    格式: 外部类名.内部类名 对象名 = 外部类对象.内部类对象;
//例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 
        }
    }
}
  1. 成员内部类的修饰符：
    private： 为了保证数据的安全性
    static： 为了方便访问数据
    注意:
    a:静态内部类访问的外部类数据必须用静态修饰。
    b: 成员方法可以是静态的也可以是非静态的
  2. 成员内部类被静态修饰后的访问方式是:
    格式: 外部类名.内部类名 对象名 = 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
        }
    }
}
  1. 局部内部类访问局部变量
    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() ;  // 调用方法
    }
}
匿名内部类
  1. 匿名内部类: 就是局部内部类的简化写法。
  2. 前提：存在一个类或者接口;这里的类可以是具体类也可以是抽象类。
  3. 格式：
    new 类名或者接口名(){
    重写方法;
    } ;
  4. 本质：是一个继承了该类或者实现了该接口的子类匿名对象。
//例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();
}
  1. 匿名内部类经常用于作为参数传递，或者作为返回值返回
  • 作为参数传递：
//例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关键字
  1. 包的概述: 就是文件夹
  2. 包的作用: 用来解决同一个路径下不能存在同名文件的问题(分类管理)
  3. 包的划分:
    按照功能
    按照模块
  4. 定义包的格式：
    package 包名;
    多级包用.分开即可
  5. 定义包的注意事项：
    A:package语句必须是程序的第一条可执行的代码
    B:package语句在一个java文件中只能有一个
    C:如果没有package，默认表示无包名
import关键字
  1. 导包的概述：
    不同包下的类之间的访问，我们发现，每次使用不同包下的类的时候，都需要加包的全路径。比较麻烦。这个时候，java就提供了导包的功能
  2. 导包格式
    import 包名;
    注意：这种方式导入是到类的名称。
四种权限修饰符

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

权限修饰符本类同一个包下(子类和无关类)不同包下(子类)不同包下(无关类)
privateY
默认YY
protectedYYY
publicYYYY

[注]：有Y的表示可以在此情况下使用

常见修饰符
  1. 修饰符：
    权限修饰符：private，默认的，protected，public
    状态修饰符：static，final
    抽象修饰符：abstract
  2. 修饰类的关键字：
    权限修饰符：默认修饰符，public
    状态修饰符：final
    抽象修饰符：abstract
    用的最多的就是：public
  3. 修饰成员变量的关键字：
    权限修饰符：private，默认的，protected，public
    状态修饰符：static，final
    用的最多的就是：private
  4. 修饰构造方法的关键字：
    权限修饰符：private，默认的，protected，public
    用的最多的就是：public
  5. 修饰成员方法的关键字：
    权限修饰符：private，默认的，protected，public
    状态修饰符：static，final
    抽象修饰符：abstract
    用的最多的就是：public
  6. 除此以外的组合规则：
    成员变量：public static final
    成员方法：
    public static
    public abstract
    public final

//下篇再见…谢谢

Tigirs
关注
专栏目录
Java入门第五天4-java方法参数类型详解
weixin_47019045的博客
07-04 1105
方法的参数是基本类型的时候： 形式参数的改变不影响实际参数。 形式参数：用于接收实际数据的变量 实际参数：实际参与运算的变量 方法的形式参数是基本类型的图解： 基本数据类型作为参数传递，形式参数的改变不影响实际参数 引用数据类型作为参数传递，形式参数的改变直接影响实际参数 方法的形式参数是引用类型图： 需求：把遍历数组改进为方法实现，并调用方法 2.2、方法练习之数组获取最值 需求：把获取数组最值改进为方法实现，并调用方法......
java 参数类型_Java的数据类型
weixin_28792813的博客
02-20 1052
Java的数据类型分为两大块，一个是基本数据类型，一个是引用类型，如下：实际编程中，应当要注意下变量的范围，如byte的范围是-128~127，如果初始赋值超过范围，那么就会报错，如下aa=128赋值，超过127，就出现报错改成在范围之内，就可以了，如下：一、整数类型int 的范围大概在 -21亿~21亿， java目前支持二进制、八进制、十进制、十六进制的表示二进制的表示，在数字前加0b八进制的...
java参数类型详细介绍（简单易懂）
qq_59430243的博客
03-17 1625
java参数类型
java参数类型详解
lixiangchibang的博客
04-25 3293
一、标准参数，即在JVM的各个版本中基本不变的，相对比较稳定的参数 -help -server -client -version -showversion -cp -classpath 二、X参数，非标准化参数，变化比较小的参数 -Xint：解释执行 -Xcomp：第一次使用就编译成本地代码 -Xmixed：混合模式，JVM自己来决定是否编译成本地代码，默认使用的就是混合模式 三、XX参数，特点是非标准化参数，相对不稳定，主要用于JVM调优和Debug 1、Boolean类型 ..
Java参数的数据类型
MoXie_的博客
08-09 1137
Java 的数据类型分为值类型和引用类型，这两种类型在作为参数使用时是有区别的。 值类型的参数 当方法的参数是值类型时，因为值类型变量里存放的即变量的值，形参和实参会完成变量值的拷贝。当方法内代码完成形参值的改变时，实参不会同步改变 引用类型的参数 Java中的引用类型变量里存储的是对象的内存地址，通过内存地址可以访问到对象的属性和方法。 当引用类型变量完成相互赋值时，即完成对象地址的拷贝，而非对象属性的拷贝。 ...
5 Java的基本程序设计结构（基本语法5）- 面向对象进阶（静态变量和方法、继承、多态（父类强转子类）、包、权限修饰符和代码块、接口、内部类、抽象类和抽象方法）
最新发布
smalltorch的博客
07-30 541
定义：被static修饰的成员变量，叫做静态变量。特点：**被该类所有对象共享（简单来说你修改任意一个对象里面的static成员变量，所有对象的该成员变量的值都会变）调用方式**（1）直接类名调用（推荐）（2）对象名调用关于被该类所有对象共享这个举个例子说明一下。一个学生类，里面有一个静态成员变量是老师，修改任意一个学生对象的老师这个成员变量，其余学生对象的老师也会统一修改。简单来说，静态成员变量是属于这个类，是属于所有对象，修改一个对象就会影响所有对象。
Java面向对象编程（上）：类和对象及类的成员
anndy_的专栏
08-21 751
Java面向对象编程面向过程（OOP）与面向对象（POP）类：class拓展知识:JavaBean拓展知识:UML类图对象(类的实例化)：new 类()内存的解析匿名对象类的成员属性(变量)：Field行为(方法)：Method方法的重载方法参数的值传递机制递归(recursion)方法构造器(或构造方法)关键字this关键字package关键字import 面向过程（OOP）与面向对象（POP） 面向过程:Procedure Oriented Programming; 面向对象:Object Orien
5、Java类成员、面向对象的基本特征
Mr_Llz的博客
03-10 4291
> 类的5个成员：属性、方法、构造器、代码块、内部类 > Java的3大基本特性：封装、继承、多态 > ----封装：安全、简单方便、对使用者隐藏实现细节 > ----继承：代码复用、扩展，表示is-a的关系 > ----多态：提高代码灵活性，增强代码功能
Java笔记 - 黑马程序员_03（继承，修饰符，多态，抽象类，接口，内部类）
逸乐的博客
04-22 2529
1. 继承 1.1 继承的概述 继承是面向对象三大特征之一。可以使得子类具有父类元素的属性和方法，还可以在子类中重新定义，追加属性和方法。 继承的格式： 格式：public class 子类名 extends 父类名 案例：public class ZI extends FU{} FU类为父类（superclass），超类，基类 ZI类为子类（subclass），派生类，扩展类 继承中子类的特点： 子类可以有父类的内容 子类也可以有自己特有的内容
思维导图02----Java面向对象
chenyao的博客~
07-05 1071
Java面向对象----思维导图 下载地址: https://download.csdn.net/download/q863672107/20016435 以下是自动转换的MakeDown文本 Java面向对象 面向对象(OOP)是相对面向过程(POP)而言的 面向过程强调的是功能行为, 以函数为最小单位, 考虑怎么做。 面向对象将功能封装进对象, 强调具备了功能的对象, 以类/对象作为最小单位, 考虑谁来做。 面向对象的特点: 抽象, 分类, 继承, 聚合, 多态等 面向对象三大特征 封装和隐藏
java 参数的数据类型_关于java数据类型和参数
weixin_33100393的博客
02-28 629
最近看了一些资料，清理了一下java基础方面的知识，现写下点笔记，待以后查阅。1:java的数据类型可以分为引用类型和原始类型(或内置类型)。2:java编程语言只有值传递参数。参考了网上的一些说话，边的两点其实可以通过一个例子来解释。classTblBsUserType(){privateLongbutyId;privateTblBsDepartmentTypetblBsDepartmen...
Java基础——参数传参（基本类型，引用类型传参）
yexiann的博客
10-05 8304
java中基本数据类型和引用数据类型作为参数传递时的原理和过程，并解释了值传递与引用传递在Java中的区别，并涉及部分java的内存模型
参数类型
努力奋斗的超人
12-12 272
声明值的类型，类型不符合则保错，语法类似java var isBoolean:boolean = true; //布尔console.log(isBoolean) var isString:string = "jiaChao"; //字符串 console.log(isString) var isNumber:number = 123; //数字 console.log(isNumber
java 传递参数类型_传递给Java中的方法时,如何要求参数为两种类型
weixin_35531726的博客
02-16 641
在一个类中,我必须调用另一个需要两个参数的类的构造函数,即IHelloServiceConnectionObserver和ContextWrapper.问题是他们都是这个.注意：ContextWrapper是一个我无法控制的框架类(实际上是android.content.ContextWrapper).我的类(一个Android Activity)已经是一个ContextWrapper,我想把它混...
JavaSE——面向对象（六）（方法参数类型及返回值类型，内部类，匿名内部类）
weixin_44324174的博客
12-25 162
1.方法参数类型及返回值类型 概述 有没有想过这样一个问题，当方法的形式参数是一个类名，抽象类名，接口名。以及方法的返回值类型是类类型，抽象类类型，接口类型是怎么办？ 形参为类名，抽象类名，接口名时（案例演示） //形参为类名时 package com.westmo.demo4; public class MyTest { public static void main(Str...
javaSE学习09（形参与返回值---引用数据类型，内部类）
weixin_44643735的博客
10-28 129
形参和返回值 1.类名作为形参和返回值 方法的形参是类名，其实需要的是该类的对象 方法的返回值是类名，其实返回的是该类的对象 2.抽象类作为形参和返回值 方法的的形参是抽象类名，其实需要的是该抽象类的子类对象 方法的返回值是抽象类名，其实返回的是该抽象类的子类对象 3.接口名作为形参和返回值 方法的形参是接口名，其实需要的是该接口的实现类对象 方法的返回值是接口名，其实返回的是该接口的实现类对...
java 方法中的参数类型是类类型的
热门推荐
不言尘世
08-02 1万+
今天做作业遇到方法中的参数类型是类类型的；有点懵。所以上网查了一些资料，并且和参数类型是基本数据类型的比较了一下。 1方法参数类型是基本数据类型的： public void test(int a) { a=6; System.err.println(a); } public static void main(String[] args) { Student student= new...
Java 可变参数列表（参数类型后面三个点...）
qq_28043563的博客
06-04 3110
Java类型后面三个点(String…)，是从Java 5开始，Java语言对方法参数支持一种新写法，叫可变长度参数列表，其语法就是类型后跟…，表示此处接受的参数为0到多个Object类型的对象，或者是一个Object[]。public class test { public static void main(String[] args) { testVar...
public static void main 参数解析
qinuna's home
09-09 1418
public class HelloWorld { public static void main(String[] args) { System.out.println("Hello World"); } } 当创建了一个 Java 类，并使用 javac 命令编译 .java 文件后，Java 文件会被编译解析成 .class 文件（字节码文件） 有了字节码文件，我们就可以使用 java 命令运行字节码文件 使用命令 javac、java 即可运行一个 .java 文
Java深度解析：匿名对象与内部类应用
"Java编程中的匿名对象与匿名内部类是两种高级特性的应用，它们在实际开发中有着重要的作用。本文将详细讲解这两种概念及其应用场景。" 在Java编程中，匿名对象指的是没有名称的对象实例，它是在创建时直接通过new...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值