精华内容
下载资源
问答
  • 类名作为形式参数 :其实这里需要的是该类对象 public class Test { public static void main(String[] args) { // 创建老师对象 Teacher t= new Teacher(); // 创建学生对象 Student s= new ...

    Student.java

    public class Student {
        public void study()
        {
            System.out.println("好好学习,天天向上");
        }
    
    }

     

    Teacher.java

    public class Teacher {
        public void test(Student s)
        {
            s.study();
        }
    
    }

     

    Test.java

    //类名作为形式参数 :其实这里需要的是该类对象
    public class Test {
        public static void main(String[] args) {
            //创建老师对象
            Teacher t=new Teacher();
            //创建学生对象
            Student s=new Student();
            t.test(s);
        }
    
    }

     

    转载于:https://www.cnblogs.com/long-holiday/p/10245277.html

    展开全文
  • 参数传递以及返回值

    2019-10-13 14:48:30
    类名作为形式参数 抽象类名作为形式参数 接口名作为形式参数 返回值 在使用完一个方法时,我们经常需要一个返回值,对于基本类型,返回的就是该基本类型的一个值,这里介绍几种引用类型的返回值 类名作为返回值 ...

    在这里插入图片描述

    参数传递

    在调用一个方法时,我们经常传入我们需要的参数,对于基本类型的传入,在执行方法时直接用即可,这里仅介绍几种引用类型的参数传递

    1. 类名作为形式参数
      如果一个方法的形参要一个类 类型,就传入一个该类的对象
    package org.westos.demo2;
    
    public class MyTest {
        public static void main(String[] args) {
            Student student = new Student();
            //调用方法,传入该类对象
            method(student,30);
            System.out.println(student.num);
        }
        public static void method(Student student,int num){
            student.num = num;
        }
    }
    class Student{
        int num = 2;
        public void method(Student student,int num){//参数类型为类 类型
            student.num= num;
        }
    }
    

    在这里插入图片描述
    根据代码可知,创建对象时完成初始化,此时对象里的的num时2,在调用方法时,传入30,替代了原来的2,所以最后的输出是30;如果在调用方法时,是重新创建一个对象并调用方法,那么在主方法里输出的num就是第一次创建对象时的初始化num=2

    1. 抽象类名作为形式参数
      如果一个方法的形参要一个抽象类 类型,就传入一个该抽象类的子类对象
    package org.westos.demo2;
    
    public class MyTest {
        public static void main(String[] args) {
            MyClass myClass = new MyClass();
            //调用方法,传入抽象类的子类对象
            method(myClass,15);
            System.out.println(myClass.num);
        }
        //定义方法,传入抽象类 类型参数
        public static void method(Student student,int num){
            student.method(num);
        }
    }
    abstract class Student{//抽象类
        int num = 2;
        public abstract void method(int num);
    }
    
    class MyClass extends Student{//定义抽象类的子类
        int num = 10;
        public void method(int num){
            this.num = num;
        }
    }
    

    在这里插入图片描述
    3. 接口名作为形式参数
    如果一个方法的形参要一个接口 类型,就传入一个该接口的子类对象

    package org.westos.demo2;
    
    public class Test3 {
        public static void main(String[] args) {
            AA aa = new AA();//创建子类对象
            //调用方法,传入接口的子类对象
            method(aa,30);
            System.out.println(aa.num);
        }
        public static void method(MyInterface myInterface,int num){
            myInterface.method(num);
        }
    }
    interface MyInterface {//定义接口
        void method(int num);
    }
    class AA implements MyInterface{//定义一个接口子类
        int num = 19;
        public void method(int num){
            this.num = num;
        }
    }
    

    在这里插入图片描述

    1. 匿名内部类作为形式参数
      匿名内部类作为参数传递,匿名内部类本身就是类或者接口的子类对象
    package org.westos.demo2;
    
    public class MyTest {
        public static void main(String[] args) {
            //通过匿名内部类实现接口调用method方法
            method(new Myinterface(){
                @Override
                public void show(){
                    System.out.println("你好");
                }
            });
            //也可以给匿名内部类起个名,然后实现接口并调用方法
            Myinterface myinterface = new Myinterface() {
                @Override
                public void show() {
                    System.out.println("我好");
                }
            };
            myinterface.show();
            //通过匿名内部类继承抽象类,并调用method2方法
            method2(new MyClass() {
                @Override
                public void show() {
                    System.out.println("他好");
                }
            });
            //也可以给匿名内部类起个名,然后继承抽象类调用方法
            MyClass myClass = new MyClass() {
                @Override
                public void show() {
                    System.out.println("大家好");
                }
            };
            myClass.show();
        }
        //接口作为参数传递
        public static void method(Myinterface myinterface){
            myinterface.show();
        }
        //抽象类作为参数传递
        public static void method2(MyClass myClass){
            myClass.show();
        }
    }
    //定义一个接口
    interface Myinterface{
        void show();
    }
    //定义一个抽象类
    abstract class MyClass{
        public abstract void show();
    }
    

    在这里插入图片描述

    返回值

    在使用完一个方法时,我们经常需要一个返回值,对于基本类型,返回的就是该基本类型的一个值,这里介绍几种引用类型的返回值

    1. 类名作为返回值
      如果一个方法的返回值要一个类 类型,就返回一个该类的对象
    package org.westos.demo2;
    
    public class Test {
        public static void main(String[] args) {
            Student student=method();
            System.out.println(student.num);
        }
        //定义一个方法,返回值为是一个类 类型
        public static Student method(){
            Student student = new Student();
            student.num=22;
            //返回该类对象
            return student;
        }
    }
    class Student{
        int num = 11;
    }
    

    在这里插入图片描述
    2. 抽象类名作为返回值
    如果一个方法的返回值要一个抽象类 类型,就返回一个该抽象类的子类对象

    package org.westos.demo2;
    
    public class Test {
        public static void main(String[] args) {
            AA aa = new AA();
            method(aa,33);
            System.out.println(aa.num);
        }
        //定义一个方法,返回值为是一个抽象类 类型
        public static Student method(Student student,int num){
            AA aa = new AA();
            aa.num=num;
            //返回该抽象类的子类对象
            return aa;
        }
    }
    abstract class Student{
        int num = 11;
        public abstract void getStudent(Student student,int num);
    }
    class AA extends Student{
        int num = 22;
        public void getStudent(Student student,int num){
            this.num=num;
            student.num=num;
        }
    }
    

    在这里插入图片描述
    这里有一个问题,既然我们传入了的num=33,为什么输出显示的是22呢?因为首先在创建子类对象时初始化后,num=22,在调用方法传入num=33,返回一个对象,而这个对象没有人接收,所以无法得以输出,输出的num依然是最开始的22;如果想输出33,需要重建一个对象接收返回值,在通过对象名.num就可输出33
    3. 接口名作为返回值
    如果一个方法的返回值要一个接口 类型,就返回一个该接口的子类对象

    package org.westos.demo2;
    
    public class Test {
        public static void main(String[] args) {
            AA aa = new AA();
            AA aaa = (AA) method(aa,400);
            System.out.println(aa.num);
            System.out.println(aaa.num);
        }
        //定义一个方法,返回值为是一个接口类型
        public static MyInterface method(MyInterface myInterface,int num){
            AA aa = new AA();
            aa.num = num;
            //返回接口的子类对象
            return aa;
        }
    }
    //定义一个接口
    interface MyInterface{
        int num = 100;
        public MyInterface Interface(MyInterface myInterface,int num);
    }
    //定义接口的子类
    class AA implements  MyInterface{
        int num =200;
        public MyInterface Interface(MyInterface myInterface,int num){
            AA aa = new AA();
            aa.num = 300;
            return aa;
        }
    }
    

    在这里插入图片描述

    1. 匿名内部类作为返回值
      匿名内部类作为返回值,返回的对象就是类或者接口的子类对象
    package org.westos.demo2;
    
    public class MyTest {
        public static void main(String[] args) {
            //调用method方法
            Myinterface myinterface = method();
            myinterface.show();
            //调用method2方法
            MyClass myClass = method2();
            myClass.show();
    
        }
        //匿名内部类作为返回值,返回接口的子类对象
        public static Myinterface method(){
            Myinterface myinterface = new Myinterface() {
                @Override
                public void show() {
                    System.out.println("aaa");
                }
            };
            return myinterface;
        }
        //匿名内部类作为返回值,返回抽象类的子类对象
        public static MyClass method2(){
            MyClass myClass = new MyClass() {
                @Override
                public void show() {
                    System.out.println("bbb");
                }
            };
            return myClass;
        }
    
    }
    //定义一个接口
    interface Myinterface{
        void show();
    }
    //定义一个类实现接口
    class A implements Myinterface{
        public void show(){
            System.out.println("AAA");
        }
    }
    //定义一个抽象类
    abstract class MyClass{
        public abstract void show();
    }
    //定义一个类继承抽象类
    class B extends MyClass{
        public void show(){
            System.out.println("BBB");
        }
    }
    

    运行结果:
    在这里插入图片描述

    其他知识

    链式编程

    链式编程可以使得代码可读性高,链式编程的原理就是返回一个this对象,就是返回本身,达到链式效果
    举个例子:

    package org.westos.demo2;
    
    public class Test2 {
        public static void main(String[] args) {
            //链式编程
            Student student = new Student().setAge(18).setName("张三");
            System.out.println(student.getName());
            System.out.println(student.getAge());
        }
    }
    class Student{
        private String name;
        private int age;
    
        public String getName() {
            return name;
        }
    
        public Student setName(String name) {
            this.name = name;
            return this;
        }
    
        public int getAge() {
            return age;
        }
    
        public Student setAge(int age) {
            this.age = age;
            return this;
        }
    }
    

    在这里插入图片描述

    package关键字

    • 概述:package,包,也就是文件夹,解决同一路径下不能存在同名文件的问题
    • 注意事项:
      (1)package语句必须是程序的第一条可执行代码
      (2)package语句在一个java文件中只能由一个
      (3)如果没有package语句,默认表示无包名
      在这里插入图片描述

    import关键字

    • 概述: 在每次访问不同包下类时,我们都需要进行导包,而导包则需要import关键字
    • 格式:import 包名
      在这里插入图片描述

    权限修饰符

    在这里插入图片描述
    另外,状态修饰符static可以修饰成员变量,成员方法;而final可以修饰类,成员变量和成员方法
    抽象修饰符abstract可以修饰类,成员方法

    展开全文
  • 1、类名作为形式参数传递 如果一个方法的形参要一个类类型,那就传一个该类对象 举例: public class MyTest { public static void main(String[] args) { //如果一个方法的形参要一个类类型,就传一个该类对象 ...

    面向对象(五)

    一、参数传递

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

    	如果一个方法的形参要一个类类型,那就传一个该类对象
    

    举例:

    public class MyTest {
        public static void main(String[] args) {
            //如果一个方法的形参要一个类类型,就传一个该类对象
            Student student = new Student();
            student.show(student,20);	//传入Student的一个对象(student)和一个整数值
            System.out.println(student.num);    //打印 20
        }
    }
    class Student{
        int num=100;
        public void show(Student stu,int num){
            stu.num=num;
        }
    }
    

    2、抽象类名作为形式参数

    	如果一个方法的形参要一个抽象类 类型,那就传一个实现该类的子类的对象
    

    举例:

    public class MyTest2 {
        public static void main(String[] args) {
            //如果一个方法的形参要一个抽象类 类型,那就传一个该类的子类对象
            Dog dog = new Dog();
            setMethod(dog,4);   //传入实现Animal类的类的对象(dog)和一个整数值
        }
        private static void setMethod(Animal an,int num) {
            an.show(num);   //调用show()方法
        }
    }
    abstract class Animal{
        public abstract void show(int a);
    }
    class Dog extends Animal{
        @Override
        public void show(int num) {
            System.out.println(num);    //打印num值:4
        }
    }
    

    3、接口作为形式参数

    	如果一个方法的形参要一个接口 类型,那就传一个实现该接口的子类的对象
    

    举例:

    public class MyTest3 {
        public static void main(String[] args) {
            //如果一个方法的形参要一个接口 类型,那就传一个实现该接口的子类的对象
            MyClass myClass = new MyClass();
            test(myClass,22);   //传入一个实现该接口的子类的对象(myClass)和一个整数值
        }
    
        private static void test(MyInterface myInterface,int b) {
            myInterface.show(b);    //调用show()方法
        }
    }
    
    interface MyInterface{
        void show(int a);
    }
    
    class MyClass implements MyInterface{
        @Override
        public void show(int a) {
            System.out.println(a);  //打印a的值:22
        }
    }
    

    二、返回值

    1、类名作为返回值类型

    	如果一个方法的返回值类型是类 类型,那就返回一个该类对象
    

    举例:

    public class MyTest {
        public static void main(String[] args) {
            //如果一个方法的返回值类型是一个类 类型,那就返回一个该类对象
            Student student = new Student();
            student.num=20;     //给student.num赋值20
            Student student1 = student.getStudent(111);   //获取返回值,即student对象,并赋给student1
            System.out.println(student1.num);   //打印student1.num的值:111
        }
    }
    class Student {
        int num=10;
        public Student getStudent(int num){
            this.num=num;   //相当于student.num=num;重新赋值111
            return this;    //谁调用这个方法this就代表谁,在此this代表student
        }
    }
    

    2、抽象类名作为返回值类型

    	如果一个方法的返回值类型是接口类型,那就返回一个实现该接口的子类的对象
    

    举例:

    public class MyTest2 {
        //如果一个方法的返回值类型是接口类型,那就返回一个实现该接口的子类的对象
        public static void main(String[] args) {
            MyInterface anInterface = getInterface();   //调用getInterface()方法并接收其返回值,赋给anInterface
            anInterface.show(1000); //调用show()方法
        }
        
        private static MyInterface getInterface() {
            return new MyClass();   //返回一个实现该接口的子类的对象(new MyClass())
        }
    }
    
    interface  MyInterface{
        void show(int num);
    }
    
    class MyClass implements  MyInterface{
        @Override
        public void show(int num) {
            System.out.println(num);    //打印: 1000
        }
    }
    

    3、接口名作为返回值类型

    	如果一个方法的返回值类型是抽象类 类型,那返回一个实现该抽象类的子类的对象
    

    举例:

    public class MyTest3 {
        //如果一个方法的返回值类型是抽象类 类型,那返回一个实现该抽象类的子类的对象
        public static void main(String[] args) {
            Animal animal = getAnimal(new Cat());   //调用getAnimal(Cat cat)方法并获取其返回值赋给animal
            animal.test();      //调用test()方法
        }
        private static Animal getAnimal(Cat cat) {
            return cat;     //返回实现抽象类Animal的子类的对象(cat)
        }
    }
    
    abstract class Animal{
        public abstract void test();
    }
    
    class Cat extends Animal{
    
        @Override
        public void test() {
            System.out.println("abc");  //打印abc
        }
    }
    
    展开全文
  • 类名作为形式参数 如果你以后看到一个方法的形参要一个类 类型你就传一个该类对象 抽象类名作为形式参数 如果你以后看到一个方法的形参要一个 抽象类 类型,你就传一个该类的子类对象 接口名作为形式参数 如果你...

    参数传递

    类名作为形式参数

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

    抽象类名作为形式参数

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

    接口名作为形式参数

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

    类名作为返回值类型

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

    抽象类名作为返回值类型

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

    接口名作为返回值类型

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

    链式编程

    当我调用完一个方法后,这个方法会返回一个对象,那我就可以紧接着再去打点,去调用对象中的方法

    个方法后,这个方法会返回一个对象,那我就可以紧接着再去打点,去调用对象中的方法

    展开全文
  • 面向对象基础1.面向过程与面向对象的区别面向过程方法面向对象方法2. 类,对象,成员变量和方法类的定义对象的定义3.对象的内存图手机类的...类名作为形式参数和返回值类型类名作为形式参数传递类名作为返回值类型 ...
  • 参数传递问题:

    2017-12-16 16:35:58
    作为形式参数的问题?(理解) (1)如果你看到一个方法需要的参数是一个类名,就应该知道这里实际需要的是一个具体的对象。 /* 形式参数的问题: 基本类型:形式参数的改变不影响实际参数 引用类型:形式参数的...
  • 一、类名作为形式参数 A:案例演示: 类名作为形式参数 当你以后看到一个方法的形参要一个 类 类型,你就传递一个该类的对象。 二、抽象类名作为形式参数 A:案例演示: 抽象类名作为形式参数 当你以后看到一个方法的...
  • 1. 类名作为形式参数 将new出来的学生对象当作形式参数进行传递 class student{ public void eat(){ System.out.println("就是爱吃肉啊"); } } class studentdemo{ public void method(student s){ s.eat(); }...
  • 类名作为形式参数传递一个该类的对象; ​ C.抽象类名作为形式参数传递一个该抽象类的子类对象; ​ D.接口名作为形式参数:传递一个实现该接口的子类对象; 2.返回值 ​ A.基本类型做为形式参数:返回一个基本...
  • 【修饰符列表】构造方法名(形式参数列表){ 构造方法体; } 构造方法名和类名一致 构造方法用来创建对象,以及完成属性初始化操作 构造方法返回值类型不需要写,连void也不能写 构造方法的返回值类型实际上是当前...
  • 在这里我用一个例子说明类作为形式参数的问题? 如果你看到一个方法需要的参数是一个类名,就应该知道这里实际需要的是一个具体的对象。 /* 形式参数的问题: 基本类型:形式参数的改变不影响实际参数 引用类型:...
  • 类名作为形式参数 ​ 一个方法的形参要一个 类 类型,你就传递一个该类的对象 抽象类名作为形式参数 ​ 一个方法的形参要一个抽象类 类型,你就传递一个该抽象类的子类对象 接口名作为形式参数 ​ 一个方法的...
  • 类名作为形式参数 当看到一个方法的形参要一个类 类型,就传递一个该类的对象。 抽象类名作为形式参数 当看到一个方法的形参要一个抽象类 类型的时候,就传递一个该抽象类的子类对象。 接口名作为形式参数 当看到一...
  • JAVA SE之面向对象4

    2021-05-08 14:33:57
    面向对象1 方法参数类型以及返回值类型问题研究1.1 类名作为形式参数1.2 抽象类名作为形式参数1.3 接口名作为形式参数1.4 类名作为返回值类型1.5 抽象类名作为返回值类型1.6 接口名作为返回值类型1.7 链式编程1.8 ...
  • 2. 构造方法的定义【修饰符列表】构造方法名(形式参数列表){ 构造方法体; }构造方法名和类名一致构造方法用来创建对象,以及完成属性初始化操作构造方法返回值类型不需要写,连void也不能写构造方法的返回值类型...
  • 10.01_面向对象(类名作为形式参数)(掌握) A:案例演示: 类名作为形式参数 当你以后看到一个方法的形参要一个 类 类型,你就传递一个该类的对象。 public class MyTest { public static void main(String[] args) {...
  • java第十二天学习笔记

    2020-04-24 18:23:06
    一、类名作为形式参数(掌握) A:案例演示: 类名作为形式参数 public class MyTest { public static void main(String[] args) { //参数传递 //当你以后看到一个方法的形参,要一个类 类型(引用类型)你就传递一个...
  • 类名作为形式参数或返回值 如果一个方法形参类型为 类 或者返回值类型为 类,则传递一个该类的对象。例: public class demo1 { public static void main(String[] args) { Student student = new Student(); ...
  • 类名作为形式参数:当看到一个方法的形参要一个类类型,就传递一个该类的对象 抽象类名作为形式参数:当以后看到一个方法的形参要一个抽象类类型,就传递一个该抽象类的子对象 接口名作为形式参数:当看到一个方法的...
  • 类名作为形式参数 以后如果你看的一个方法的形参要一个类,类型,那你就传递一个该类的对象 案例演示 public class MyTest { public static void main(String[] args) { //以后如果你看的一个方法的形参要一个类...
  • 1.类名作为形式参数 当你以后看到一个方法的形参要一个 类 类型,你就传递一个该类的对象。 public static void main(String[] args) { Student student = new Student(); set(student, 60); student.show(new ...
  • Java学习第十二天----方法参数类型以及返回值类型...(1)类名作为形式参数: public class MyTest { public static void main(String[] args) { //参数传递 //当看到一个方法的形参,要一个类 类型 就传递一个该类...
  • 1.类名作为形式参数 当你以后看到一个方法的形参要一个 类 类型,你就传递一个该类的对象。 public static void main(String[] args) { Student student = new Student(); set(student, 60); student.show(new ...
  • 类名作为形式参数 当你以后看到一个方法的形参,要一个类 类型,你就传递一个该类的对象。 public static void set(Student student, int num) { student.num = num; } Student student = new Student(); set...
  • 文章目录1.传参和返回值类型1.1 形参1.2 返回值类型1.3 链式编程2.导包3.权限修饰符4.内部类4.1 成员内部类4.2 ...类名作为形式参数时,你就传一个该类对象 public class MyDemo { public static void main(String...
  • 类名作为形式参数、返回值类型 当你以后看到一个方法的形参要一个 类 类型,你就传递一个该类的对象。 当你以后看到一个方法的返回值类型,是一个类 类型,你就返回一个该类的对象。 抽象类名作为形式参数、...
  • 类名作为方法的形式参数 //Teacher.java public class Teacher { public void test(Student s) {//接收传递过来的Student对象的地址值 s.study(); } } //Student.java public class Student { public void ...
  • javase笔记day10

    2020-04-22 20:47:12
    类名作为形式参数 当你以后看到一个方法的形参,要一个类 类型(引用类型)你就传递一个该类的对象。 引用类型传递,形参的改变会影响实参 属于引用传递传递的是地址值 public class MyTest { public static...

空空如也

空空如也

1 2 3 4 5
收藏数 89
精华内容 35
关键字:

类名作为形式参数传递