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

//外部类

public class HelloWorld {

    private String name = "爱慕课";

    // 外部类中的show方法

    public void show() { 

// 定义方法内部类

class MInner {

int score = 83;

public int getScore() {

return score + 10;

}

}

// 创建方法内部类的对象

        MInner mi=new MInner();

        // 调用内部类的方法

int newScore=mi.getScore();

System.out.println("姓名：" + name + "\n加分后的成绩：" + newScore);

}

// 测试方法内部类

public static void main(String[] args) {

// 创建外部类的对象

        HelloWorld mo=new HelloWorld();

        // 调用外部类的方法

mo.show();

}

}

1、 静态内部类不能直接访问外部类的非静态成员，但可以通过 new 外部类().成员 的方式访问 

2、 如果外部类的静态成员与内部类的成员名称相同，可通过“类名.静态成员”访问外部类的静态成员；如果外部类的静态成员与内部类的成员名称不相同，则可通过“成员名”直接调用外部类的静态成员

3、 创建静态内部类的对象时，不需要外部类的对象，可以直接创建 内部类 对象名= new 内部类();

调用外部类中道德参数加“this."

public class HelloWorld {

    String name; // 声明变量name

String sex; // 声明变量sex

static int age;// 声明静态变量age

    // 构造方法

public HelloWorld() { 

System.out.println("通过构造方法初始化name");

name = "tom";

}

    // 初始化块

{ 

System.out.println("通过初始化块初始化sex");

sex = "男";

}

    // 静态初始化块

static{ 

System.out.println("通过静态初始化块初始化age");

age = 20;

}

public void show() {

System.out.println("姓名：" + name + "，性别：" + sex + "，年龄：" + age);

}

public static void main(String[] args) {

        javascript:;

        // 创建对象

HelloWorld hello = new HelloWorld();

// 调用对象的show方法

        hello.show();

}

}

方法二：

public class HelloWorld {

    // 定义静态变量score1

    static int score1 = 86;

    // 定义静态变量score2

static int score2 = 92; 

static int result=score1+score2;

    // 定义静态方法sum，计算成绩总分，并返回总分

public static int sum() {

      return result;

}

public static void main(String[] args) {

        // 调用静态方法sum并接收返回值

int allScore =HelloWorld.sum();

System.out.println("总分：" + allScore);

}

}

方法一：

public class HelloWorld {

    // 定义静态变量score1

    static int score1 = 86;

    // 定义静态变量score2

static int score2 = 92; 

    // 定义静态方法sum，计算成绩总分，并返回总分

public static int sum() { 

  int result=score1+score2;

      return result;

}

public static void main(String[] args) {

        // 调用静态方法sum并接收返回值

int allScore =HelloWorld.sum();

System.out.println("总分：" + allScore);

}

}

public class HelloWorld {

    // 定义静态变量，保存班级名称

static String className = "JAVA开发一班";

public static void main(String[] args) {

// 访问静态变量，输出班级名称

System.out.println("通过类名访问className:"+HelloWorld.className);

// 使用对象名访问静态变量

HelloWorld hello=new HelloWorld();

System.out.println("通过对象名访问className:"+hello.className);

//使用对象名的形式修改静态变量的值

hello.className="爱慕课";

System.out.println("通过类名访问修改后的className:"+HelloWorld.className);

System.out.println("通过对象名访问修改后的className:"+hello.className);

}

}

super关键字：在对象的内部使用，可以代表父类对象。

1. 访问父类的属性

   super.age

2. 访问父类的方法

   super.eat()

   
   

   super的应用

   （1)子类的构造的过程当中必须调用其父类的构造方法

   (2)如果子类的构造方法中没有显示调用父类的构造方法，则系统默认调用父类无参的构造方法

   (3)如果显式的调用构造方法，必须在子类的构造方法的第一行

   （4）如果子类构造方法中既没有显式调用父类的构造方法，而父类有没有无参的构造方法，则编译出错。

接口定义的基本语法

【修饰符】interface接口名【exteds 父类口1，父类口2...】

{

零个到多个常量定义。。。

零个到多个抽象方法的定义

}

final 关键字

使用final关键字做标识有“最终的”含义

final可以修饰类、方法、属性和变量

1. final修饰类，则该类不允许被继承

2. final修饰方法，则该方法不允许被覆盖（重写）

3. final修饰属性，则该类的属性不会进行隐式的初始化（类的初始化属性必须有值）或在构造方法中赋值（但只能选其一）

4. final修饰变量，则该变量的值只能赋一次值，即变为变量

接口定义

和类定义不同，定义接口不再使用class关键字，而是使用interface关键字

继承的初始化顺序：

1. 初始化父类再初始化子类

2. 先执行初始化对象中属性，再执行构造方法中的初始化。

继承初始化顺序

    父类属性初始化----->父类构造方法初始化----->子类属性初始化---->子类构造方法初始化