Java入门day10(形式参数和返回值的问题、包、权限修饰符、内部类)

最新推荐文章于 2022-09-17 17:34:55 发布

一起找点乐子

最新推荐文章于 2022-09-17 17:34:55 发布

阅读量138

点赞数

分类专栏： Study 文章标签： java 内部类

本文链接：https://blog.csdn.net/qq_41861598/article/details/113443013

版权

Study 专栏收录该内容

13 篇文章 0 订阅

订阅专栏

形式参数和返回值的问题

（1）形式参数

类名：需要该类的对象

抽象类名：需要该类的子类对象

接口名：需要该接口的实现类对象

（2）返回值

类名：返回该类的对象

抽象类名：返回该类的子类对象

接口名：返回该接口的实现类对象

（3）链式编程

对象.方法1( ).方法2…方法n

这种用法：在调用完方法1，2等它们返回的是该类的对象

包

(1)其实就是文件夹

(2)作用

A：区分同名的类

B：对类进行分类管理

a:按功能分

b:按模块分

(3)包的定义

package 包名;

多级包用 . 分开

(4)注意事项

a：package语句必须在文件中的第一条有效语句

b：在一个java文件中，只能有一个package

c：如果没有package，默认就是无名包

(5)带包的编译和运行

a：手动式(自己创建文件夹)

b：自动式—>javac -d. HelloWorld.java

权限修饰符

权限修饰符	本类	同包中	不同包的子类	不同包的无关类
public	√	√	√	√
protected	√	√	√
默认	√	√
private	√

注意：外部类只能用public 和默认修饰

常见的修饰符

(1)分类

权限修饰符： private、默认、protected、public

状态修饰符： final、static

抽象修饰符： abstract

(2)常见的类及其组成的修饰符

类：（外部类+内部类）外部类只能public和默认修饰内部类中的局部内部类只能默认修饰符，成员内部类4种都可以

private、默认、protected、public、abstract、final、static(内部类可以使用)

成员变量：

private、默认、protected、public、final、static

成员方法：

private、默认、protected、public、final、static、abstract

构造方法：

private、默认、protected、public、

内部类

（1）把类定义在另一个类的内部，该类就被称为内部类。

举例：把类B定义在类A中，类B就被称为内部类。

（2）内部类的访问规则

A：可以直接访问外部类的成员，包括私有

B：外部类想要访问内部类成员，必须创建对象

（3）内部类的分类

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

B：局部内部类在局部位置定义的类

（4）成员内部类

A/B可有可无一般开发的时候加private

A：private 为了数据的安全性

B：static 为了访问的方便性

成员内部类不是静态的：

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

成员内部类是静态的：

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

在这里自己编程发现：

1.必须所有的权限修饰符满足（外部类+内部类+内部类的属性的权限修饰符），才能在其他包的其它类下访问

2. 当成员内部类被静态符修饰，只有成员内部类的成员也被静态修饰符修饰时，才可以用（外部类.内部类.属性）的方式访问

3.当成员内部类被静态修饰符修饰时，成员内部类只能访问外部类静态的属性

//com.zhou包下的外部类Test和成员内部类Test2
package com.zhou;
public class Test {
    private int num = 10;
    private static int num2 = 20;
    //成员内部类
    public static class Test2 {
        public static int age = 3;
        String name = "A";
    }
}
//其他包下的非继承测试类
public class Demo {
    public static void main(String[] args) {
        Test.Test2 tt = new Test.Test2();
        int x = Test.Test2.age;
        System.out.println(x);
    }
}
1.如果将age或者Test2或者Test的任意权限修饰符修改改了，测试类中都会报错。必须都为public
2.如果将age的static删去，测试类无法访问 会报错    
3.如在内部类中访问num会报错而num2不会
4.成员内部类未被static修饰，其成员属性也不可以

成员内部类的面试题

注意：

1.内部类和外部类没有继承关系

2.通过外部类名限定this对象（指外部类的对象）Outer.this

public class Test {
    public int num = 10;
    public 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(Test.this.num);//10
            System.out.println(new Test().num);//10
        }
    }
}

(5)局部内部类

1.可以直接访问外部类的成员

2.在局部位置，可以创建内部类对象，通过对象调用内部类方法，来使用局部内部类功能

A:局部内部类访问局部变量必须加上final修饰

B:为什么呢？

因为局部变量使用完毕就消失，而堆内存的数据并不会立即消失。所以，堆内存还使用该变量，而该变量已经没有了。为了让该值还存在，就加final修饰。通过反编译工具我们看到，加入final后，堆内存直接存储的是值，而不是变量。

JDK1.8之后，可以不用加final修饰了，因为jdk1.8以后，即使你不加也会默认加上的。

public class Test {
    private int num = 10;

    public void show() {
        final int num2 = 20;//这里以前需要加final
        class Inner {

            public void study() {
                System.out.println(num);
                System.out.println(num2);//不加final这里会报错 现在不会了
            }
        }
        Inner i = new Inner();
        i.study();
    }
}

（6）匿名内部类

A：是局部内部类的简化形式（相当于是默认修饰符，所以被实现的类和接口必须在同一个包下）

B：前提

存在一个类或者接口

C：格式

new 类名或者接口名( ){

重写方法；

}

D：本质

其实是继承该类或者实现该接口的子类匿名对象

（7）匿名内部类在开发中的使用

我们在开发的时候，会看到抽象类，或者接口作为参数。而这个时候，我们知道实际需要的是一个子类对象。如果该方法仅仅调用一次，我们就可以使用匿名内部类的格式简化。

interface Person{
	public abstract void study();
}
		
class PersonDemo {
	public void method(Person p) {
		p.study();
	}
}
		
class PersonTest {
	public static void main(String[] args) {
		PersonDemo pd = new PersonDemo ();
		pd.method(new Person() {
		public void study() {
			System.out.println("好好学习");
		}
		});
	}
}

(8)匿名内部类的面试题(补齐代码)

		interface Inter {
			void show();
		}
		class Outer {
			补齐代码
		}
		class OuterDemo{
			public static void main(String []args) {
				Outer.method().show();
			}
		}
		要求输出HelloWorld

		答案：
		class Outer {
			public static Inter method() {
		
				return new Inter() {
					public void show() {
						System.out.println("HelloWorld");
					}	
				};
			}
		}

注意点：

1. Outer.method()可以看出method()应该是Outer中的一个静态方法

2. Outer.method().show()可以看出method（）方法的返回值是一个对象，是一个接口

3. 接口中void show(); 默认是 public abstract 所以在写实现类时权限不能缩小