12_包，修饰符，内部类，匿名类总结

最新推荐文章于 2022-01-30 15:54:59 发布

Singinwind

最新推荐文章于 2022-01-30 15:54:59 发布

阅读量185

点赞数

分类专栏： Java

本文链接：https://blog.csdn.net/u012184326/article/details/80151617

版权

Java 专栏收录该内容

19 篇文章 0 订阅

订阅专栏

一、包

特点:Java中出现包是为了方便管理.java文件，使在分层的时候结构清晰，方便开发。包的本质是磁盘中的文件夹。在.java中定义java文件在包的位置用关键字Package。import关键字用来导入包。在java的包中，分为同一包中不同类的访问，不同的包中不同类的访问特点:

同一包中不同类的访问:不需要导包

不同包中不同类的访问:需要导包，eclipse的快捷键是ctrl+shift+o;

二、修饰符

概述:在Java中常见的修饰符有public、default、protected、private、abstract、final、static等。

1.public、default(缺省，什么也没写的时候)、protected、private的访问权限

public: 本类、相同包下的不同类、不同包下的不同类(有没有继承关系的类都可以)

default: 本类相同包下的不同类

protected:本类相同包下的不同类、不同包下的子类

private: 本类

2)java中所有的修饰符可以修饰的内容:

public: 类成员变量成员方法构造方法

default: 类成员变量成员方法构造方法

protecetd: 类成员变量成员方法构造方法(修饰构造方法，仅仅给子类使用)

private: 成员变量成员方法构造方法(不能修饰类假设修饰类，就不能被其他类访问并创建对象。这样是没有意义的;可以修饰成员方法，只限于给本类的方法访问，这样的修饰一般是作为某些小功能，辅助其他方法做一个大功能的方法;可以修饰构造函数，防止被创建对象，这样常应用于一些抽象类的工具函数。)

final: 类成员变量成员方法(只能修饰这三种，不能修饰构造函数，构造函数只限于被public、protected、private修饰符修饰。- - 修饰类，不能被继承;修饰成员变量，只能用作常量，不可以再改变值;修饰成员方法，不能被重写）

static: 成员变量成员方法(被修饰的成员，属于类；能用类名.成员名称直接访问;优先于对象而存在;被该类的所有对象所共享;随着类的加载而加载，随着类的消失而消失;应用:工具类)

abstract: 类成员方法(修饰类，作为抽象类，不能创建对象，其类的抽象方法必须要被子类实现;修饰成员方法，没有函数体，其所在的类也编程抽象类。不能和static final共存)

三、内部类

1.概述:一个事物内部里面的事物描述称为内部类。Java使用内部类有两个好处：1.使类的描述更加完善 2.在一次性使用对象的时候，可以更加节省内存

2.分类:内部类分为成员内部类、局部内部类、静态内部类

1) 成员内部类: 定义在类中的成员位置

       (1)格式:
          class A{
             class AA{
                成员
              }
 
          }

(2)使用:有两种方法生成内部类对象

[1].直接调用

 A.AA a = new A().new AA();

[2].通过A中的成员方法访问内部类

 class A{
                AA method()
                {
                   return new AA();
                   
                }
                class AA{
                   void function()
                   {}           
                }
             }
 
             //调用
             main()
             { new A().method().function()
 
public class PrivateTest {
 public PrivateTest()
 {
 
 }
 public static void main(String[] args) {
  new A().getAA().function();
 }
}
class A{
 AA getAA()
 {
  return new AA();
 }
 class AA
 {
  void function()
  {
   System.out.println("调用成员内部类AA的方法成功");
  }
 }
}}

2).局部内部类:

一般用在成员方法里面,一次性使用节省内存

/*
 * 局部内部类
 * 
 */
public class SingleClass {
public static void main(String[] args) {
 A a = new A();
 a.function();
}
}
class A
{
 void function()
 {
  class AA
  {
   void method()
   {
    System.out.println("调用局部内部类的方法成功");
   }
  }
  AA aa = new AA();
  aa.method();
 }
}

3) 静态成员内部类:

public class StaticClassTest {
 public static void main(String[] args) {
  A.AA aa = new A.AA();
  aa.function();
 }
}
class A
{
 static class AA
 {
  void function()
  {
   System.out.println("静态成员内部类调用成功");
  }
 }
 
}

四、匿名类

概述:和匿名对象类似，一次性使用节约内存，作为方法参数可以使用

案例1:

public class Test {
 public static void main(String[] args) {  
  //补齐代码

//第一种方式:

new InterA() {
   
   @Override
   public void showA() {
    System.out.println("第一种方式");
   }
  }.showA();

//第二种方式:

new A().methodA(new InterA() {
   
   @Override
   public void showA() {
    System.out.println("第二种方式");
   }
  });
 }
}

//定义接口
interface InterA {
 void showA(); 
}
class A {
 public void methodA(InterA a) {
  a.showA();  
 }
 
}

案例2：

/*
 *
 * 第三题：分析以下需求，并用代码实现
 interface Inter {
  void show(); 
 }
 class Outer { 
  //补齐代码 
 }
 public class OuterDemo {
  public static void main(String[] args) {
     Outer.method().show();
    }
 }
 要求在控制台输出”HelloWorld” 
 */
 
interface Inter {
 void show(); 
}
class Outer { 
 //补齐代码 
 
 public static Inter method()
 {
  return new Inter() {
   
   @Override
   public void show() {
    System.out.println("HelloWorld");
   }
  };
  
 }
}
public class OuterDemo {
 public static void main(String[] args)
 {
  Outer.method().show();
   }
}