第五章 –– 类的修饰符和内部类

1:形式参数和返回值的问题(理解)

(1)形式参数：

类名：需要该类的对象

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

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

(2)返回值类型：

类名：返回的是该类的对象

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

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

(3)链式编程

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

这种用法：其实在方法1()调用完毕后，应该一个对象；

      方法2()调用完毕后，应该返回一个对象。

  方法n()调用完毕后，可能是对象，也可以不是对象。

 

2:包(理解)

(1)其实就是文件夹

(2)作用：

A:区分同名的类

B:对类进行分类管理

a:按照功能分

b:按照模块分

(3)包的定义(掌握)

package 包名;

多级包用.分开。

(4)注意事项：(掌握)

A:package语句必须在文件中的第一条有效语句

B:在一个java文件中，只能有一个package

C:如果没有package，默认就是无包名

(5)带包的编译和运行

A:手动式

B:自动式(掌握)

javac -d . HelloWorld.java

3:导包(掌握)

(1)我们多次使用一个带包的类，非常的麻烦，这个时候，Java就提供了一个关键字import。

(2)格式：

import 包名...类名;

另一种：

import 包名...*;(不建议)

(3)package,import,class的顺序

package > import > class

4:权限修饰符(掌握)

(1)

权限修饰符	本类	同一个包下	不同包下的子类	不同包下的无关类
private	Y
默认	Y	Y
Protected	Y	Y	Y
public	Y	Y	Y	Y

(2)这四种权限修饰符在任意时刻只能出现一种。

public class Demo {}

 

例子:

--------------------------------------------------------------------------------

/*

    修饰符：
        权限修饰符：private，默认的，protected，public
        状态修饰符：static，final
        抽象修饰符：abstract

4

4

 

1

    修饰符：

2

        权限修饰符：private，默认的，protected，public

3

        状态修饰符：static，final

4

        抽象修饰符：abstract

        

    类：
        权限修饰符：默认修饰符，public
        状态修饰符：final
        抽象修饰符：abstract
        
        用的最多的就是：public

6

6

 

1

    类：

2

        权限修饰符：默认修饰符，public

3

        状态修饰符：final

4

        抽象修饰符：abstract

5

6

        用的最多的就是：public

        

    成员变量：
        权限修饰符：private，默认的，protected，public
        状态修饰符：static，final
        
        用的最多的就是：private

5

5

 

1

    成员变量：

2

        权限修饰符：private，默认的，protected，public

3

        状态修饰符：static，final

4

5

        用的最多的就是：private

        

    构造方法：
        权限修饰符：private，默认的，protected，public
        
        用的最多的就是：public

4

4

 

1

    构造方法：

2

        权限修饰符：private，默认的，protected，public

3

4

        用的最多的就是：public

        

    成员方法：
        权限修饰符：private，默认的，protected，public
        状态修饰符：static，final
        抽象修饰符：abstract
        
        用的最多的就是：public

6

6

 

1

    成员方法：

2

        权限修饰符：private，默认的，protected，public

3

        状态修饰符：static，final

4

        抽象修饰符：abstract

5

6

        用的最多的就是：public

        

    除此以外的组合规则：
        成员变量：public static final
        成员方法：public static 
         public abstract
                 public final

5

5

 

1

    除此以外的组合规则：

2

        成员变量：public static final

3

        成员方法：public static 

4

         public abstract

5

                 public final

        

*/

//此处不允许使用修饰符private
//此处不允许使用修饰符protected
//此处不允许使用修饰符static
public class Demo {
    //成员变量
    private int x = 10;
    int y = 20;
    protected int z = 30;
    public int a = 40;
    public final int b = 50;
    public static int c = 60;
    public static final int d = 70;
    //此处不允许使用修饰符abstract
    //abstract int e = 80;
    
    //构造方法
    private Demo(){}
    
    Demo(String name){}
    
    protected Demo(String name,int age) {}
    
    public Demo(String name,int age,String address) {}
    
    //此处不允许使用修饰符static
    //public static Demo(){}
    //此处不允许使用修饰符final
    //public final Demo() {}
    //此处不允许使用修饰符abstract
    //public abstract Demo(){}
    
    //成员方法
    //static void show() {}
    //abstract void show();
    //final void show(){}
}

36

36

 

1

//此处不允许使用修饰符private

2

//此处不允许使用修饰符protected

3

//此处不允许使用修饰符static

4

public class Demo {

5

    //成员变量

6

    private int x = 10;

7

    int y = 20;

8

    protected int z = 30;

9

    public int a = 40;

10

    public final int b = 50;

11

    public static int c = 60;

12

    public static final int d = 70;

13

    //此处不允许使用修饰符abstract

14

    //abstract int e = 80;

15

16

    //构造方法

17

    private Demo(){}

18

19

    Demo(String name){}

20

21

    protected Demo(String name,int age) {}

22

23

    public Demo(String name,int age,String address) {}

24

25

    //此处不允许使用修饰符static

26

    //public static Demo(){}

27

    //此处不允许使用修饰符final

28

    //public final Demo() {}

29

    //此处不允许使用修饰符abstract

30

    //public abstract Demo(){}

31

32

    //成员方法

33

    //static void show() {}

34

    //abstract void show();

35

    //final void show(){}

36

}

6:内部类(理解)

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

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

(2)内部类的访问规则

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

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

(3)内部类的分类

A:成员内部类

B:局部内部类

(4)成员内部类的访问方式

A:private 为了数据的安全性

--------------------------------------------------------------------------------

案例：我有一个人(人有身体，身体内有心脏。)

class Body {
	private class Heart {
		public void operator() {
			System.out.println("心脏搭桥");
		}
	}

	public void method() {
		if (如果你是外科医生) {
			Heart h = new Heart();
			h.operator();
		}
	}
}

14

14

 

1

class Body {

2

    private class Heart {

3

        public void operator() {

4

            System.out.println("心脏搭桥");

5

        }

6

    }

7

8

    public void method() {

9

        if (如果你是外科医生) {

10

            Heart h = new Heart();

11

            h.operator();

12

        }

13

    }

14

}

 

按照我们刚才的讲解，来使用一下

Body.Heart bh = new Body().new Heart();
bh.operator();
//加了private后，就不能被访问了，那么，怎么玩呢?
Body b = new Body();
b.method();

5

5

 

1

Body.Heart bh = new Body().new Heart();

2

bh.operator();

3

//加了private后，就不能被访问了，那么，怎么玩呢?

4

Body b = new Body();

5

b.method();

--------------------------------------------------------------------------------

 

B:static 为了访问的方便性

--------------------------------------------------------------------------------

class Outer {
    private int num = 10;
    private static int num2 = 100;
    
    //内部类用静态修饰是因为内部类可以看出是外部类的成员
    public static class Inner {
        public void show() {
            //System.out.println(num);
            System.out.println(num2);
        }
 
        public static void show2() {
            //System.out.println(num);
            System.out.println(num2);
        }       
    }
}
 
class InnerClassDemo4 {
    public static void main(String[] args) {
        //使用内部类
        // 限定的新静态类
        //Outer.Inner oi = new Outer().new Inner();
        //oi.show();
        //oi.show2();
        
        //成员内部类被静态修饰后的访问方式是:
        //格式：外部类名.内部类名 对象名 = new 外部类名.内部类名();
        Outer.Inner oi = new Outer.Inner();
        oi.show();
        oi.show2();
        
        //show2()的另一种调用方式
        Outer.Inner.show2();
    }
}

36

36

 

1

class Outer {

2

    private int num = 10;

3

    private static int num2 = 100;

4

5

    //内部类用静态修饰是因为内部类可以看出是外部类的成员

6

    public static class Inner {

7

        public void show() {

8

            //System.out.println(num);

9

            System.out.println(num2);

10

        }

11

12

        public static void show2() {

13

            //System.out.println(num);

14

            System.out.println(num2);

15

        }       

16

    }

17

}

18

19

class InnerClassDemo4 {

20

    public static void main(String[] args) {

21

        //使用内部类

22

        // 限定的新静态类

23

        //Outer.Inner oi = new Outer().new Inner();

24

        //oi.show();

25

        //oi.show2();

26

27

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

28

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

29

        Outer.Inner oi = new Outer.Inner();

30

        oi.show();

31

        oi.show2();

32

33

        //show2()的另一种调用方式

34

        Outer.Inner.show2();

35

    }

36

}

--------------------------------------------------------------------------------

成员内部类不是静态的：

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

成员内部类是静态的：

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

 

(5)成员内部类的面试题(填空)

面试题:

要求请填空分别输出 30,20,10

注意: 内部类和外部类没有继承关系

--------------------------------------------------------------------------------

 

class Outer {
	public int num = 10;

	class Inner {
		public int num = 20;

		public viod show() {
			int num = 30;
			System.out.println(num);
			System.out.println(this.num);
			System.out.println(Outer.this.num);
			// System.out.println(new Output.num);
		}
	}
}

15

15

 

1

class Outer {

2

    public int num = 10;

3

4

    class Inner {

5

        public int num = 20;

6

7

        public viod show() {

8

            int num = 30;

9

            System.out.println(num);

10

            System.out.println(this.num);

11

            System.out.println(Outer.this.num);

12

            // System.out.println(new Output.num);

13

        }

14

    }

15

}

 

--------------------------------------------------------------------------------

(6)局部内部类  面试题

A:局部内部类访问局部变量必须加final修饰。
 
B:为什么呢?
    因为局部变量使用完毕就消失，而堆内存的数据并不会立即消失。所以，堆内存还是用该变量，而改变量已经没有了。
    为了让该值还存在，就加final修饰。
    通过反编译工具我们看到了，加入final后，堆内存直接存储的是值，而不是变量名。
    局部内部类也是在堆中的, 声明周期长, 所以访问外部变量需要将外部的变量修饰成final 常量

7

7

 

1

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

2

3

B:为什么呢?

4

    因为局部变量使用完毕就消失，而堆内存的数据并不会立即消失。所以，堆内存还是用该变量，而改变量已经没有了。

5

    为了让该值还存在，就加final修饰。

6

    通过反编译工具我们看到了，加入final后，堆内存直接存储的是值，而不是变量名。

7

    局部内部类也是在堆中的, 声明周期长, 所以访问外部变量需要将外部的变量修饰成final 常量

 

(7)匿名内部类(掌握)

 

A:是局部内部类的简化形式

B:前提

存在一个类或者接口

C:格式:

new 类名或者接口名() {

重写方法;

}

D:本质：

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

 

(8)匿名内部类在开发中的使用

 

我们在开发的时候，会看到抽象类，或者接口作为参数。

而这个时候，我们知道实际需要的是一个子类对象。

如果该方法仅仅调用一次，我们就可以使用匿名内部类的格式简化。

--------------------------------------------------------------------------------

 

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("好好学习，天天向上");
			}
		});
	}
}

20

20

 

1

interface Person {

2

    public abstract void study();

3

}

4

5

class PersonDemo {

6

    public void method(Person p) {

7

        p.study();

8

    }

9

}

10

11

class PersonTest {

12

    public static void main(String[] args) {

13

        PersonDemo pd = new PersonDemo();

14

        pd.method(new Person() {

15

            public void study() {

16

                System.out.println("好好学习，天天向上");

17

            }

18

        });

19

    }

20

}

--------------------------------------------------------------------------------

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

--------------------------------------------------------------------------------

interface Inter {
	void show();
}

class Outer {
	// 补齐代码
	public static Inter method() {
		return new Inter() {
			public void show() {
				System.out.println("HelloWorld");
			}
		};
	}
}

class OuterDemo {
	public static void main(String[] args) {
		Outer.method().show(); // "HelloWorld"
	}
}

x

20

 

1

interface Inter {

2

    void show();

3

}

4

5

class Outer {

6

    // 补齐代码

7

    public static Inter method() {

8

        return new Inter() {

9

            public void show() {

10

                System.out.println("HelloWorld");

11

            }

12

        };

13

    }

14

}

15

16

class OuterDemo {

17

    public static void main(String[] args) {

18

        Outer.method().show(); // "HelloWorld"

19

    }

20

}

--------------------------------------------------------------------------------

/*

Test类，测试

 

导包：

格式：import 包名;

这种方式导入是到类的名称。

注意：我们用谁就导谁。

面试题：

package,import,class有没有顺序关系?

有。

package > import > class

Package:只能有一个

import:可以有多个

class:可以有多个，以后建议是一个

*/

 

 

来自为知笔记(Wiz)