包和权限修饰符

Posted 2021-01-12 samuraihuang

//包名采用全部小写字母

* 包的特点：

 * 可以有多层

 * 不同包下的文件名可以重复

 * 包的声明必须是第一行代码

 

* 不同包之间的互相访问

 * 使用类的全名

 * 使用关键字import将类导入

 *

 *

 * 注意：*代表的是通配符，代表导入了这个包下所有的类，并没有导入子包下的类

 *

 * 类的全名：包名.类名

 

 

权限修饰符:

	public	protected	default	private
同一类中	√	√	√	√
同一包中(子类与无关类)	√	√	√
不同包的子类	√	√
不同包中的无关类	√

 

什么是内部类

将类写在其他类的内部，可以写在其他类的成员位置和局部位置，这时写在其他类内部的类就称为内部类。其他类也称为外部类。

 

 

1.1 成员内部类

成员内部类，定义在外部类中的成员位置。与类中的成员变量相似，可通过外部类对象进行访问

A:定义格式

class 外部类 {

修饰符 class 内部类 {

//其他代码

}

}

B:访问方式

外部类名.内部类名 变量名 = new 外部类名().new 内部类名();

 

* 成员内部类：

 

 * 在类的成员位置，和成员变量以及成员方法所在的位置是一样的

 

 * 在内部类当中，可以直接访问外部类的成员，包括私有成员

 

 

 

* 成员内部类的修饰符：

 

 * 我们可以使用权限修饰符修饰成员内部类，但是如果使用私有来修饰，则无法在其他类中访问

 

 * 我们可以使用static修饰成员内部类，不用再创建外部类的对象了

 

 *

 

 * 我们可以使用abstract,final修饰成员内部类

 

 

1.2 局部内部类

  局部内部类，定义在外部类方法中的局部位置。与访问方法中的局部变量相似，可通过调用方法进行访问

* 局部内部类在方法内，出了方法之后就无法使用

 

 

1.3 匿名内部类

 

* 匿名内部类:

 

 * 可以把匿名内部类看成是一个没有名字的局部内部类

 

 * 定义在方法当中

 

 * 必须在定义匿名内部类的时候创建他的对象

 

 * 格式：

 

 * new 类/接口(){

 

 * 如果是创建了继承这个类的子类对象，我们可以重写父类的方法

 

 * 如果是创建了实现这个接口的子类对象，我们必须要实现该接口的所有方法

 

 * };

 

 * 原理：而是创建了继承这个类的子类对象或者是创建了实现这个接口的子类对象

 

 

 

* 匿名内部类:

 

 * 可以把匿名内部类看成是一个没有名字的局部内部类

 

 * 定义在方法当中

 

 * 必须在定义匿名内部类的时候创建他的对象

 

 * 格式：

 

 * new 类/接口(){

 

 * 如果是创建了继承这个类的子类对象，我们可以重写父类的方法

 

 * 如果是创建了实现这个接口的子类对象，我们必须要实现该接口的所有方法

 

 *

 

 * 原理：而是创建了继承这个类的子类对象或者是创建了实现这个接口的子类对象

 

 

 1 public class InnerDemo4 {
 2     public static void main(String[] args) {
 3         Outer o = new Outer();
 4         o.method();
 5     }
 6 }
 7 
 8 interface Inner {
 9     public void function();
10 }
11 
12 class Outer {
13     public void method() {
14         
15         /*new Inner() {
16 
17             @Override
18             public void function() {
19                 System.out.println("function");
20             }
21             
22         }.function();;*/
23         
24         Inner i = new Inner() {
25 
26             @Override
27             public void function() {
28                 System.out.println("function");
29             }        
30         };
31         
32         i.function();
33         i.function();
34     }
35 }

 

使用匿名对象的方式，将定义子类与创建子类对象两个步骤由一个格式一次完成，。虽然是两个步骤，但是两个步骤是连在一起完成的。

 

 1 //已经存在的父类：
 2 public abstract class Person{
 3     public abstract void eat();
 4 }
 5 //定义并创建该父类的子类对象，并用多态的方式赋值给父类引用变量
 6 Person  p = new Person(){
 7     public void eat() {
 8         System.out.println(“我吃了”);
 9 }
10 };

 

匿名内部类如果不定义变量引用，则也是匿名对象。代码如下：

1 new Person(){
2     public void eat() {
3         System.out.println(“我吃了”);
4 }
5 }.eat();

 

匿名内部类作为参数传递

 

 1 package com.itheima_04;
 2 
 3 public interface Animal {
 4     public abstract void eat();
 5 }
 6 
 7 package com.itheima_04;
 8 
 9 public class Cat implements Animal {
10     @Override
11     public void eat() {
12         System.out.println("猫吃鱼");
13     }
14 }
15 
16 
17 package com.itheima_04;
18 
19 public class Dog implements Animal {
20     @Override
21     public void eat() {
22         System.out.println("狗啃骨头");
23     }
24 }
25 
26 
27 package com.itheima_04;
28 /*
29  * 匿名内部类的应用场景:
30  *         作为参数进行传递
31  *         
32  *      
33  */
34 public class InnerDemo5 {
35     public static void main(String[] args) {
36          //method(new Dog());
37          //method(new Cat());
38         method(
39                 new Animal() {
40                     @Override
41                     public void eat() {
42                         System.out.println("猫吃鱼");
43                     }
44                 }    
45         );
46     }    
47     public static void method(Animal a) {
48         a.eat();
49     }
50 }