Java(二)：Java对象和类

目录

一、Java内部类

1、非静态内部类

2、私有的内部类

3、静态内部类

4、从内部类访问外部类成员

二、源文件声明规则

三、匿名类

1、匿名类继承一个父类

2、匿名类实现一个接口

四、一个简单的例子

一、Java内部类

要访问内部类，可以通过创建外部类的对象，然后创建内部类的对象来实现。

嵌套类有两种类型：

• 非静态内部类
• 静态内部类

1、非静态内部类

非静态内部类是一个类中嵌套着另外一个类。 它有访问外部类成员的权限， 通常被称为内部类。

由于内部类嵌套在外部类中，因此必须首先实例化外部类，然后创建内部类的对象来实现。

class OuterClass{
    int x = 10;

    class InnerClass{
        int y = 5;
    }
}
public class myMainClass {
    public static void main(String[] args){
        OuterClass myOuter = new OuterClass();
        OuterClass.InnerClass myInner = myOuter.new InnerClass();
        System.out.println(myInner.y+ myOuter.x);
    }

//输出结果：15

2、私有的内部类

内部类可以使用 private 或 protected 来修饰，如果你不希望内部类被外部类访问可以使用 private 修饰符： 

class Outerclass {
    int x = 10;

    private class Innerclass {
        int y = 5;
    }
}

public class MainClass {
    public static void main(String[] args) {
        Outerclass myOuter = new Outerclass();
        Outerclass.Innerclass myInner = myOuter.new Innerclass();
        System.out.println(myInner.y + myOuter.x);
    }
}

 运行结果：（ Innerclass 设置为私有内部类，执行会报错）

MyMainClass.java:12: error: OuterClass.InnerClass has private access in OuterClass
    OuterClass.InnerClass myInner = myOuter.new InnerClass();
             ^

3、静态内部类

静态内部类可以使用 static 关键字定义，静态内部类我们不需要创建外部类来访问，可以直接访问它：

class Outer {
    int x = 10;

    static class Inner {
        int y = 5;
    }
}

public class c_1_11 {
    public static void main(String[] args) {
        Outer.Inner myInner = new Outer.Inner();
        System.out.println(myInner.y);
    }
}

//运行结果：5

注意：静态内部类无法访问外部类的成员。

4、从内部类访问外部类成员

 内部类一个高级的用法就是可以访问外部类的属性和方法：

class Outerrclass{
    int x = 10;

    class Innerrclass{
        public int myInnerMethod(){
            return x;
        }
    }
}
public class c_1_111 {
    public static void main(String[] args){
        Outerrclass myOuter = new Outerrclass();
        Outerrclass.Innerrclass myInner = myOuter.new Innerrclass();
        System.out.println(myInner.myInnerMethod());
    }
}

//运行结果：10

二、源文件声明规则

当在一个源文件中定义多个类，并且还有import语句和package语句时，要特别注意这些规则。

• 一个源文件中只能有一个 public 类
• 一个源文件可以有多个非 public 类
• 源文件的名称应该和 public 类的类名保持一致。例如：源文件中 public 类的类名是 Employee，那么源文件应该命名为Employee.java。
• 如果一个类定义在某个包中，那么 package 语句应该在源文件的首行。
• 如果源文件包含 import 语句，那么应该放在 package 语句和类定义之间。如果没有 package 语句，那么 import 语句应该在源文件中最前面。
• import 语句和 package 语句对源文件中定义的所有类都有效。在同一源文件中，不能给不同的类不同的包声明。

类有若干种访问级别，并且类也分不同的类型：抽象类和 final 类等。

三、匿名类

Java 中可以实现一个类中包含另外一个类，且不需要提供任何的类名直接实例化。

主要是用于在我们需要的时候创建一个对象来执行特定的任务，可以使代码更加简洁。

匿名类是不能有名字的类，它们不能被引用，只能在创建时用 new 语句来声明它们。

匿名类语法格式：

class outerClass {

    // 定义一个匿名类
    object1 = new Type(parameterList) {
         // 匿名类代码
    };
}

以上的代码创建了一个匿名类对象 object1，匿名类是表达式形式定义的，所以末尾以分号；来结束。匿名类通常继承一个父类或实现一个接口。

 

1、匿名类继承一个父类

以下实例中，创建了 Polygon 类，该类只有一个方法 display()，AnonymousDemo 类继承了 Polygon 类并重写了 Polygon 类的 display() 方法：

class Polygon {
   public void display() {
      System.out.println("在 Polygon 类内部");
   }
}

class AnonymousDemo {
   public void createClass() {

      // 创建的匿名类继承了 Polygon 类
      Polygon p1 = new Polygon() {
         public void display() {
            System.out.println("在匿名类内部。");
         }
      };
      p1.display();
   }
}

class Main {
   public static void main(String[] args) {
       AnonymousDemo an = new AnonymousDemo();
       an.createClass();
   }
}

执行以上代码，匿名类的对象 p1 会被创建，该对象会调用匿名类的 display() 方法，输出结果为：在匿名类内部。

2、匿名类实现一个接口

以下实例创建的匿名类实现了 Polygon 接口：

interface Polygon {
   public void display();
}

class AnonymousDemo {
   public void createClass() {

      // 匿名类实现一个接口
      Polygon p1 = new Polygon() {
         public void display() {
            System.out.println("在匿名类内部。");
         }
      };
      p1.display();
   }
}

class Main {
   public static void main(String[] args) {
      AnonymousDemo an = new AnonymousDemo();
      an.createClass();
   }
}

//输出结果为：在匿名类内部。

四、一个简单的例子

在该例子中，我们创建两个类：Employee 和 EmployeeTest。

Employee 类有四个成员变量：name、age、designation 和 salary。该类显式声明了一个构造方法，该方法只有一个参数。

Employee.java 文件代码：

import java.io.*;
 
public class Employee{
   String name;
   int age;
   String designation;
   double salary;
   // Employee 类的构造器
   public Employee(String name){
      this.name = name;
   }
   // 设置age的值
   public void empAge(int empAge){
      age =  empAge;
   }
   /* 设置designation的值*/
   public void empDesignation(String empDesig){
      designation = empDesig;
   }
   /* 设置salary的值*/
   public void empSalary(double empSalary){
      salary = empSalary;
   }
   /* 打印信息 */
   public void printEmployee(){
      System.out.println("名字:"+ name );
      System.out.println("年龄:" + age );
      System.out.println("职位:" + designation );
      System.out.println("薪水:" + salary);
   }
}

下面给出EmployeeTest类，该类实例化2个 Employee 类的实例，并调用方法设置变量的值。

 EmployeeTest.java 文件代码：

import java.io.*;
public class EmployeeTest{
 
   public static void main(String[] args){
      /* 使用构造器创建两个对象 */
      Employee empOne = new Employee("RUNOOB1");
      Employee empTwo = new Employee("RUNOOB2");
 
      // 调用这两个对象的成员方法
      empOne.empAge(26);
      empOne.empDesignation("高级程序员");
      empOne.empSalary(1000);
      empOne.printEmployee();
 
      empTwo.empAge(21);
      empTwo.empDesignation("菜鸟程序员");
      empTwo.empSalary(500);
      empTwo.printEmployee();
   }
}