9.Java面向对象-方法参数类型及返回值类型、权限修饰符、内部类、匿名内部类

最新推荐文章于 2021-11-07 15:19:25 发布
最新推荐文章于 2021-11-07 15:19:25 发布
阅读量121 收藏
点赞数 1
分类专栏： Java 文章标签： java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_39004315/article/details/110534637
版权

9.Java面向对象-方法参数类型及返回值类型、权限修饰符、内部类、匿名内部类

一、类名作为形式参数

A:案例演示:	类名作为形式参数

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

package org.westos.java9;

public class Demo {
    public static void main(String[] args) {
        test test = new test();
        show(test);//fu
        testZi testZi = new testZi();
        show(testZi);//zi
    }
    //传递该类对象或者该类子类对象
    public static void show(test test){
        test.show();
    }
}

class test{
    public void show(){
        System.out.println("fu");
    }

}

class testZi extends test{
    @Override
    public void show() {
        System.out.println("zi");
    }
}

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

A:案例演示:	抽象类名作为形式参数

当你以后看到一个方法的形参要一个抽象类 类型，你就传递一个该抽象类的子类对象。

package org.westos.java9;

public class Demo{
    public static void main(String[] args) {
        zi zi = new zi();
        fu zi1 = new zi();
        //zi show
        //fu show
        show(zi); //传递子类对象用子类方式接收并传递
        //zi show
        //fu show 
        show(zi1); //传递子类对象用父类及多态形式接收并传递
        //zi show
        //fu show
        show(new zi()); //传递子类对象用匿名对象方式传递
    }
    public static void show(fu fu){
        fu.show();
        fu.show2();
        //fu.show3();报错

    }
}

abstract class fu{
    public abstract void show();
    public void show2(){
        System.out.println("fu show");
    }
}

class zi extends fu{

    @Override
    public void show() {
        System.out.println("zi show");
    }
    public void show3(){}
}

三、接口名作为形式参数

A:案例演示:	接口名作为形式参数

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

package org.westos.java9;

public class Demo {
    public static void main(String[] args) {
        zi zi = new zi();
        Testinter zi1 = new zi();
        show(zi); //传递子类对象用子类接收并传递
        show(zi1); //传递子类对象用接口及多态形式接收并传递
        show(new zi()); //传递子类对象用匿名对象方式传递
    }
    public static void show(Testinter test){
        test.show(); //zi
        test.show2(); //interface 重写之后就是打印 zizi
        //test.show3(); //报错 静态方法没有被继承，只能使用接口名调用
        Testinter.show3(); //static
    }
}

interface Testinter{
    void show();
    default void show2(){
        System.out.println("interface");
    }
    public static void show3(){
        System.out.println("static");
    }
}

class zi implements Testinter{

    @Override
    public void show() {
        System.out.println("zi");
    }

/*    @Override
    public void show2() {
        System.out.println("zizi");
    }*/
}

四、类名作为返回值类型

A:案例演示:	类名作为返回值类型

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

package org.westos.java9;

public class Demo {
    public static void main(String[] args) {
        fu show = show();
        System.out.println(show.a);
        show.show();
    }
/*    public static fu show(){
        return new zi(); //10 zi
    }*/
/*    public static fu show(){
        zi zi = new zi();
        return zi; //10 zi
    }*/
/*    public static fu show(){
        fu zi = new zi();
        return zi; //10 zi
    }*/
/*    public static fu show(){
        return new fu(); //10 fu
    }*/
    public static fu show(){
        fu fu = new fu();
        return fu; //10 fu
    }
}

class fu{
    int a=10;
    public void show(){
        System.out.println("fu");
    }
}
class zi extends fu{
    int a=20;

    @Override
    public void show() {
        System.out.println("zi");
    }
}

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

A:案例演示:	抽象类名作为返回值类型

当你以后看到一个方法的返回值类型是一个抽象类 类型，你就返回一个该抽象类的子类对象。

package org.westos.java9;

public class Demo {
    public static void main(String[] args) {
        fu show = show();
        System.out.println(show.a);
        show.show();
        show.show2();

    }
/*    public static fu show(){
        return new zi(); // 10 zizi fufu 重写后 10 zizi zizi
    }*/
/*    public static fu show(){
        zi zi = new zi();
        return zi; // 10 zizi fufu 重写后 10 zizi zizi
    }*/
/*    public static fu show(){
        fu zi = new zi();
        return zi; // 10 zizi fufu 重写后 10 zizi zizi
    }*/
/*    public static fu show(){
        return new fu(){

            @Override
            public void show() {
                System.out.println("zizi");
            }

            @Override
            public void show2() {
                System.out.println("zizi");
            }
        };// 10 zizi fufu 内部没有改写,改写之后为 10 zizi zizi
    }*/
    public static fu show(){
        fu zi = new fu() {
            @Override
            public void show() {
                System.out.println("zizi");
            }

            /*@Override
            public void show2() {
                System.out.println("zizi");
            }*/
        };
        return zi; // 10 zizi fufu 内部没有改写,改写之后为 10 zizi zizi
    }
}

abstract class fu{
    int a=10;
    public abstract void show();
    public void show2(){
        System.out.println("fufu");
    }
}

class zi extends fu{
    int a=20;
    @Override
    public void show() {
        System.out.println("zizi");
    }

/*    @Override
    public void show2() {
        System.out.println("zizi");
    }*/
}

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

A:案例演示:	接口名作为返回值类型

当你以后看到一个方法的返回值类型是一个接口 类型，你就返回一个该接口的子类对象

package org.westos.java9;

public class Demo {
    public static void main(String[] args) {
        jump show = show();
        System.out.println(show.a);
        show.show();
    }
/*    public static jump show(){
        return new tiger(); //10 jump
    }*/
/*    public static jump show() {
        tiger tiger = new tiger();
        return tiger; // 10 jump
    }*/
/*    public static jump show() {
        jump tiger = new tiger();
        return tiger; // 10 jump
    }*/
/*    public static jump show() {
        //jump jump = new jump(); //报错
        return new jump(){

            @Override
            public void show() {
                System.out.println("jumpjump");
            }
        }; // 10 jumpjump
    }*/
    public static jump show() {
        //jump jump = new jump(); //报错
        jump tiger = new jump() {
            @Override
            public void show() {
                System.out.println("jumpjump");
            }
        };//使用多态的形式去接收子类对象，因为是匿名内部类，所以子类的名称是未知的，所以不能使用子类去接收它
        return tiger; // 10 jumpjump
    }
}
interface jump {
    int a=10;
    void show();
}
class tiger implements jump {
    int a=30;
    @Override
    public void show() {
        System.out.println("jump");
    }
}

七、链式编程

package org.westos.java9;

public class Demo {
    public static void main(String[] args) {
        show().show(); //lian shi bian chen
    }
    public static test show(){
        return new test();
    }
}

class test{
    public void show(){
        System.out.println("lian shi bian chen");
    }
}

八、package关键字的概述及作用

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

九、包的定义及注意事项

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

十、不同包下类之间的访问

A:案例演示
	不同包下类之间的访问
		定义两个类：Demo,Test。
			Demo
				求和方法(sum)
			Test
				测试方法(main)

package org.westos.java9;

import org.westos.java10.Demo;

public class Test {
    public static void main(String[] args) {
        System.out.println(Demo.sum(1, 2));

    }
}

package org.westos.java10;

public class Demo {
    public static int sum(int a,int b){
        return a+b;
    }
}

十一、import关键字的概述和使用

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

package org.westos.java9;

//使用import关键字导入包中的类，可以在末尾加*代表此包中所有的类，但是不建议此方法
import org.westos.java10.*;

public class Test {
    public static void main(String[] args) {
        System.out.println(new Demo().sum(1, 2));

    }
}

十二、四种权限修饰符的测试

A:案例演示
	四种权限修饰符: private(私有的)  , 默认 , protected(受保护的) , public(公共的) 
B:结论
				本类	同一个包下(子类和无关类)  不同包下(子类) 不同包下(无关类)
	private 	 Y		
	默认		 Y	           Y
	protected	 Y		       Y		           Y
	public		 Y		       Y		           Y		          Y

package org.westos.java9;


import org.westos.java10.Demo;

//需要使用该类A被protected修饰的方法的类B是该类A的子类
public class Test extends Demo{
    public static void main(String[] args) {
        Demo demo = new Demo();
        //demo.sum(5,6); 报错，不能采用此方法去使用A类中被protected修饰的方法
        System.out.println(new Test().sum(5, 6));
    }

    @Override
    protected int sum(int a, int b) {
        return super.sum(a, b);
    }
}

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

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
			 public static final
其中abstract不能与final,static,private一起使用

十四、内部类概述和访问特点

A:内部类概述:	把类定义在其他类的内部，这个类就被称为内部类。
	举例：在类A中定义了一个类B，类B就是内部类。
B:内部类访问特点
	a:内部类可以直接访问外部类的成员，包括私有。
	b:外部类要访问内部类的成员，必须创建对象。
C:案例演示
	内部类及其访问特点

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

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

package org.westos.java9;


class Test{
    public static void main(String[] args) {
        Wai.Nei nei = new Wai().new Nei();
        nei.show(); 
    }
}

class Wai {
    int a;
    class Nei{
        public void show(){
            a=10;
            Wai.this.show();
            System.out.println(a);
        }
    }
     void show(){
        System.out.println(a);
    }
}

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

A:成员内部类的修饰符：
	private 为了保证数据的安全性
	static 	为了方便访问数据
		注意事项:  a:静态内部类访问的外部类数据必须用静态修饰。
		           b: 成员方法可以是静态的也可以是非静态的
B:成员内部类被静态修饰后的访问方式是:
	格式:	外部类名.内部类名 对象名 = new 外部类名.内部类名();

package org.westos.java9;


class Test{
    public static void main(String[] args) {
        //Wai.Nei nei = new Wai.Nei(); 报错
        //new Wai().show().show(); 报错
        new Wai().show2();

    }
}

class Wai {
    int a;
    private static class Nei{
        public void show(){
            System.out.println("nei");
        }
    }
     public Nei show(){
         Nei nei = new Nei();
         return nei;
     }
     public void show2(){
        new Nei().show();
     }
}

package org.westos.java9;


class Test{
    public static void main(String[] args) {
        Wai.Nei nei = new Wai.Nei();
        nei.show();

    }
}

class Wai {
    int a;
    public static class Nei{
        public void show(){
            System.out.println("nei");
        }
    }
     public Nei show(){
         Nei nei = new Nei();
         return nei;
     }
     public void show2(){
        new Nei().show();
     }
}

十七、成员内部类的面试题

package org.westos.java9;


/*A:面试题
        要求：使用已知的变量，在控制台输出30，20，10。*/
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
            System.out.println(Outer.this.num); //10
            //System.out.println(Outer.num); //10 当 public static int num = 10;

        }
    }
}
class InnerClassTest {
    public static void main(String[] args) {
        Outer.Inner oi = new Outer().new Inner();
        oi.show();
    }
}

十八、局部内部类访问局部变量的问题

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

package org.westos.java9;

class text{
    public static void main(String[] args) {
       //inner inner = new outer().new inner(); 报错
        new outer().show(); //90
    }

}

class outer{
    public void show(){
        int a=90; //默认被final修饰
        class inner{
            public void show(){
                //a=60; 报错
                System.out.println(a);
            }

        }
        inner inner = new inner();
        inner.show();
    }
    public void showinner(){
        //inner inner = new inner(); 报错
    }
}

十九、匿名内部类的格式和理解

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

package org.westos.java9;

class text{
    public static void main(String[] args) {
        //抽象类
        new fu(){

            @Override
            public void show() {
                System.out.println("show");
            }
        }.show(); //show
        //接口
        new jump(){

            @Override
            public void show() {
                System.out.println("jump");
            }
        }.show(); //jump
    }
}

abstract class fu{
    public abstract void show();
}

interface jump{
    void show();
}

package org.westos.java9;

class test{
    private int a=90;
    public void show(){
        class nei{
           // int a=100;
            public void show(){
                System.out.println(a);
            }
        }
        nei nei = new nei();
        nei.show();
    }
}

class demo{
    public static void main(String[] args) {
        //具体类
        new test(){
           /* @Override
            public void show() {
                System.out.println("show");
            }*/
        }.show(); //90
    }
}

二十、匿名内部类的方法调用

package org.westos.java9;

class text{
    public static void main(String[] args) {
        //匿名对象调用方法
        new fu(){

            @Override
            public void show() {
                System.out.println("show");
            }
        }.show(); //show
        //多态的形式接收匿名对象调用方法,因为没有创建子类所以子类名称是未知的，也不需要知道，所以无法用子类去接收匿名对象
        fu zi1 = new fu() {

            @Override
            public void show() {
                System.out.println("show2");
            }
        };
        zi1.show(); //show2

        //匿名对象调用方法
        new jump(){

            @Override
            public void show() {
                System.out.println("jump");
            }
        }.show(); //jump
        //多态的形式接收匿名对象调用方法,因为没有创建子类所以子类名称是未知的，也不需要知道，所以无法用子类去接收匿名对象
        jump zi2 = new jump() {

            @Override
            public void show() {
                System.out.println("jump2");
            }
        };
        zi2.show(); //jump2
    }
}

abstract class fu{
    public abstract void show();
}

interface jump{
    void show();
}

二十一、匿名内部类在开发中的应用

A:问题引出
	首先回顾我们曾经讲过的方法的形式参数是引用类型的情况，
	我们知道这里需要一个子类对象。而匿名内部类就是一个子类匿名对象，
	所以，可以使用匿名内部类改进以前的做法。
B:代码如下
	//这里写抽象类，接口都行
	abstract class Person {
		public abstract void show();
	}
	
		class PersonDemo {
​			public void method(Person p) {
​				p.show();
​			}
​		}
​	
​		class PersonTest {
​			public static void main(String[] args) {
​				//如何调用PersonDemo中的method方法呢?
​				
​			}
		}

package org.westos.java9;

abstract class Person {
    public abstract void show();
}

class PersonDemo {
    public void method(Person p)
    {
        p.show();
    }
}
class PersonTest {
	public static void main(String[] args) {
	    //如何调用PersonDemo中的method方法呢?
        new PersonDemo().method(new Person() {
            @Override
            public void show() {
                System.out.println("show");
            }
        }); //show

	}
}

package org.westos.java9;

abstract class Person {
    int a=20;
    public abstract void show();
}

class PersonDemo {
    public Person method()
    {
        return new Person() {
            int a=60;
            @Override
            public void show() {
                System.out.println("show");
            }
        };
    }
}
class PersonTest {
	public static void main(String[] args) {
	    //如何调用PersonDemo中的method方法呢?
        System.out.println(new PersonDemo().method().a);//20

    }
}

package org.westos.java9;

class test{
    public static void main(String[] args) {
        new demo(){
            int a=100;
            @Override
            public void show() {
                System.out.println(a);
            }
        }.show(); //100
    }
}

abstract class demo{
    int a=50;
    public abstract void show();
}

package org.westos.java9;

class test{
    public static void main(String[] args) {
        new demo(){
            @Override
            public void show() {
                System.out.println(a);
            }
        }.show(); //50
    }
}

abstract class demo{
    int a=50;
    public abstract void show();
}

package org.westos.java9;

class test{
    public static void main(String[] args) {
        System.out.println(new demo() {
            int a = 100;
            @Override
            public void show() {
                System.out.println("a");
            }
        }.a); //100
    }
}

abstract class demo{
    int a=50;
    public abstract void show();
}

package org.westos.java9;

class test{
    public static void main(String[] args) {
        System.out.println(new demo() {
            @Override
            public void show() {
                System.out.println("a");
            }
        }.a); //50
    }
}

abstract class demo{
    int a=50;
    public abstract void show();
}

package org.westos.java9;

class test{
    public static void main(String[] args) {
        demo a = new demo() {
            int a=100;
            @Override
            public void show() {
                System.out.println("a");
            }
        };
        System.out.println(a.a); //50
    }
}

abstract class demo{
    int a=50;
    public abstract void show();
}

二十二、匿名内部类中this关键字

A: 面试题
	 interface Inter {
		public static final int a = 23 ;
	}
	
	public class Test {

		public static void main(String[] args) {
			new Inter() {
				public void show() {
					//this 代表匿名内部类
					System.out.println(this.a);//23
		
				}
			}.show();
		}
	}

package org.westos.java9;

/*A: 面试题*/
interface Inter {
    public static final int a = 23 ;
    public abstract void show();
}

public class Test {

    public static void main(String[] args) {
        new Inter() {
            @Override
            public void show() {
                //this 代表匿名内部类
                System.out.println(this.a);//23

            }
        }.show();
    }
}

package org.westos.java9;

/*A: 面试题*/
interface Inter {
    public static final int a = 23 ;
    public abstract void show();
}

public class Test {

    public static void main(String[] args) {
        new Inter() {
            int a=90;
            @Override
            public void show() {
                //this 代表匿名内部类
                System.out.println(this.a);//90

            }
        }.show();
    }
}

二十三、匿名内部类的面试题

A:面试题
	按照要求，补齐代码
	interface Inter { 
		void show(); 
	}
	
	class Outer { 
		//补齐代码 
		
	}
	
	class OuterDemo {
		public static void main(String[] args) {
			  Outer.method().show();
		  }
	}
	要求在控制台输出”HelloWorld”

package org.westos.java9;

/*A:面试题
        按照要求，补齐代码*/
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();
    }
}
/*
	要求在控制台输出”HelloWorld”*/

二十四、类中定义接口

package org.westos.java9;

// 电脑类
class Computer {
    // 内存条的接口
    private interface Memory {

        // 添加一个抽象方法
        public abstract void showMemory(String memory) ;

    }

    public void appMemory(String memory){

        new Memory() {
            public void showMemory(String memory){
                System.out.println("内存为" + memory) ;
            }
        }.showMemory(memory) ;

    }
}
// 具体类
/*
私有的东西不能被外界访问
class MemoryImpl implements Computer.Memory {
// 添加一个方法
public void showMemory(String memory){
	System.out.println("内存为" + memory) ;
}
}
*/
// 测试类
class InnerInterfaceDemo {

    public static void main(String[] args) {

        // 匿名内部类的方式
	/*
	私有的东西不能被外界访问
	new Computer.Memory() {
		public void showMemory(String memory){
			System.out.println("内存为" + memory) ;
		}
	}.showMemory("8G") ;
	*/

        // 创建Computer的对象
        Computer cp = new Computer() ;

        // 调用appMemory
        cp.appMemory("32G") ;

    }
}

package org.westos.java9;

class test{
    public static void main(String[] args) {
        new demo.jump(){

            @Override
            public void show() {
                System.out.println("show");
            }
        }.show(); //show
    }
}

class demo{
    interface jump{
        void show();
    }
}

package org.westos.java9;

class test{
    public static void main(String[] args) {
        //多态的形式接收匿名对象
        demo.jump show = new demo.jump() {

            @Override
            public void show() {
                System.out.println("show");
            }
        };
        show.show(); //show
    }
}

class demo{
    interface jump{
        void show();
    }
}
孑孓莎
关注
  • 1
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
java入门~第十一天 方法参数类型以及返回值类型问题研究
weixin_41924998的博客
07-28 505
1.方法参数类型以及返回值类型问题研究 1.01方法参数类型 1.类名作为形式参数 当你以后看到一个方法的形参要一个 类 类型，你就传递一个该类的对象。 public static void main(String[] args) { Student student = new Student(); set(student, 60); student.show(new Student(), 80);//如果新new的new Student()没有进行实例化，
Java08------方法参数类型以及返回值类型问题研究
qq_44241861的博客
07-25 736
文章目录方法参数类型类名作为形式参数抽象类名作为形式参数接口名作为形式参数返回值类型类名作为返回值类型抽象类名作为返回值类型接口名作为返回值类型链式编程包权限修饰符缺省的public：接口访问private：不能接触protected：“友好的一种”类及其组成所使用的常见修饰符内部类成员内部类成员内部类的直接使用成员内部类的常见修饰符及应用局部内部类（不常用）匿名内部类 （常用）匿名内部类的传参匿名内部类作为返回值来返回类中定义接口 方法参数类型 类名作为形式参数 当你以后看到一个方法的形参要一个 类 类型
JavaSE——面向对象（六）（方法参数类型及返回值类型，内部类，匿名内部类）
weixin_44324174的博客
12-25 143
1.方法参数类型及返回值类型 概述 有没有想过这样一个问题，当方法的形式参数是一个类名，抽象类名，接口名。以及方法的返回值类型是类类型，抽象类类型，接口类型是怎么办？ 形参为类名，抽象类名，接口名时（案例演示） //形参为类名时 package com.westmo.demo4; public class MyTest { public static void main(Str...
Java-方法参数类型以及返回值类型讨论
PreyHard的博客
10-20 7959
一.类名作为形式参数。 当类名作为形式参数时，那你就传一个该类的对象，或者直接传一个匿名对象new 类名()。 二.抽象类名作为形式参数 当抽象类名作为形式参数时，那你就传一个该类的子类对象。或者传一个该接口子类匿名对象 三.接口作为形式参数。 当接口作为形式参数时，那你就传一个该接口的子类对象，或者直接传一个该接口子类匿名对象new 类名()。 四.方法中类名作为返回值类型（返...
java方法中的参数和返回值的四种情况
weixin_44740328的博客
05-18 2391
方法中是否有参数和返回值分为四种情况： 1、无参无返 2、有参有返 3、有参无返 4、无参有返 代码实例： Student类： package com.aaa.pac.classdemo; public class Student { //属性 ---成员变量 //姓名 String name; //身高 float height; //年龄 int age; //性别 String sex; //行为
java面向对象知识点总结.pdf
09-30
以上是Java面向对象编程的主要知识点，包括类、对象、匿名对象、This关键字、构造函数、成员变量与局部变量、封装、包和权限修饰符以及继承和方法重写。理解并掌握这些概念是成为Java开发者的基石。
Programming-Concepts-COP2510:Java类
05-02
- **访问修饰符**：Java提供了public、private、protected和默认四种访问修饰符，用于控制类、成员变量和方法的访问权限。 - **类名**：遵循驼峰命名法，通常首字母大写，如`MyClass`。 - **成员变量**：类中的...
【05-面向对象(下)】
07-03
•如果希望获得包装类对象中包装的基本类型变量，则可以使用包装类提供的XxxValue()实例方法。 自动装箱与自动拆箱 •JDk还提供了自动装箱和自动拆箱。自动装箱就是把一个基本类型的变量直接赋给对应的...
java面试题-应届生面试题-面试大全
10-21
- **访问修饰符**：掌握public、private、protected以及默认访问修饰符的权限范围。 - **抽象类与接口**：理解抽象类和接口的区别，知道何时选择抽象类，何时选择接口。 - **内部类**：了解成员内部类、局部内部...
java1-6章测试题目.pdf
11-26
Java是广泛使用的面向对象编程语言，它以其跨平台能力、丰富的类库和高效性能而闻名。以下是基于给定文件内容的一些关键知识点的详细说明： 1. **JAVA 实现跨平台的原理**：Java的跨平台能力源于“一次编写，到处...
匿名内部类 的参数
无歆可行的专栏
07-11 775
public abstract class AnonymousInnerClass { public abstract void output(); } public class lll { public static void main(String[] args) { T1 tt = new T1(); AnonymousInnerClass aic = tt.
内部类_匿名内部类作实际参数_方法内的匿名内部类
New_new_zero的博客
04-07 193
package demo.oo; interface Inter3 { public abstract void show1(); public abstract void show2(); } class Outer3 { void method() { new Inter3() { public void show1() { System.out.println("只能调用一个");
匿名内部类在开发中当做参数传递
whaleluo的博客
05-04 3641
匿名内部类在开发中当做参数传递 class Test { public static void main(String[] args) { //如何调用PersonDemo中的method方法呢? PersonDemo pd = new PersonDemo (); //pd.method(new Student()); pd.method(new Person() {//
(匿名)内部类、引用类型作为方法参数和返回值
x871752024的博客
07-16 1176
内部类 在一个类中，定义了另外第一分类，成为内部类(嵌套类) public class Outer{ public class Inner{ } } Outer类，成为外部类，Inner类称为Outer类的内部类，或者是嵌套类 内部类可以使用外部类的成员，包括私有的 外部类如果使用内部类的成员，必须创建内部类的对象 成员内部类 一个类，定义在另一个类的成员位置，成员内部类，可以使用成员修饰符 内部类编译后会产生class文件：外部类名$内部类名.class 内部类成员的调用格式 外部类名.内部类名
Java基础——方法参数类型与返回值类型、权限修饰符、内部类、匿名内部类
威威的博客
11-07 671
1.方法参数类型与返回值类型 类名作为参数传递：当看到一个方法的形参需要一个类 类型时，就传递该类的对象。 抽象类名作为参数传递：当看到一个方法的形参需要一个抽象类 类型时，就传递该抽象类的子类对象。 接口名作为参数传递：当看到一个方法的形参需要一个接口 类型时，就传递一个该接口的子类对象。 类名作为返回值类型：当看到一个方法的返回值类型是一个类 类型时，就返回一个该类的对象。 抽象类名作返回值类型：当看到一个方法的返回值类型是一个抽象类 类型时，就返回一个该抽象类的子类对象。 接口名作为返回值类
匿名内部类
匿名攻城狮
05-15 632
(1)匿名内部类格式： 格式： new 父类或者接口(){ 重写接口或者父类中的方法 (一般不超过三个) }; (2)使用匿名内部类的情况： 需要有接口或者父类，并且，接口或者父类中的方法不超过三个，过多时候就不匿名了。 匿名内部类可以当做参数传递。 (3)匿名内部类测试： interface USB{ void open(); void close(); } class ...
JAVA基础知识面向对象之 ---- 参数类型与返回值类型、修饰符
qq_44823091的博客
04-18 213
JAVA基础知识面向对象之 ---- 参数类型与返回值类型、修饰符 参数类型 A：基本数据类型作为形参： ​ 当一个方法的形参为基本数据类型时，就传对应的基本数据类型。 B：类名作为形参： ​ 当一个方法的形参要一个类 类型，就传一个该类的对象。 public class MyTest { public static void main(String[] args) { ...
Java（Android）方法中匿名内部类使用方法的参数
xiaobei3120的专栏
10-15 1919
匿名内部类一般定义在一个方法的内部，如果要访问该方法的参数或者方法中定义的变量，则这些参数或者变量必须使用final修饰。 虽然匿名内部类定义在方法的内部，但在编译时内部类与外部类中的方法属于同一个级别，外部类中方法的变量或参数只是方法的局部变量，这些变量或者参数的作用域只在当前方法内部有效。但是如果这些变量用final修饰，内部类就可以保存方法变量的备份，即使方法销毁也能保证内部类在访
匿名内部类作为参数传递和返回怎么实现？
weixin_40487115的博客
10-14 2847
接口或者抽象类的匿名对象，都可以作为参数传递，达到调用方法的目的： 具体实现代码如下： public class Parameter { public static void main(String[] args) { display(new Test() {//把匿名内部类作为参数传递，可以直接重写抽象类中的方法； @Override ...
Java面向对象（进阶）- 四种权限测试与方法的重写（override-overwrite）
最新发布
11-02
"Java面向对象的进阶教程，涵盖了四种权限修饰符（private、default、protected、public）的详细测试和方法重写（override/overwrite）的概念及应用。本教程通过实例解析了不同权限修饰符在类内部、同一包内、不同包...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值