访问控制符范围：

1. private：只能在同类下使用

2. 无修饰：在同包和同类里面可以访问

3. protected：在同包，同类，子类当中可以访问

4. public：所有的地方可以访问（同包，同类，子类，其他）
   

封装：

隐藏类的内部信息，不能被其他的类给访问和使用

主要的操作就是把属性私有化（private）

然后在当前类当中写get和set方法来对私有属性进行操作

private int a=1;

getA(){return a;}

setA(int b){

a=b;

}

stasic块进行初始化的部分程序最早开始执行的部分  static int a; 

static{

 a=1; }，但static块儿只进行一次，第二次不会被执行的。

然后执行普通初始化块儿  int b;   { b=20;}

最后执行构造初始化块

静态方(类方法): 在main函数中可以用类名来直接调用，也可以对象调用，static方法对以对static变量进行操作，不能对别的变量进行赋值和别的操作。

Java 中的成员内部类

内部类中最常见的就是成员内部类，也称为普通内部类。我们来看如下代码：

运行结果为：

从上面的代码中我们可以看到，成员内部类的使用方法：

1、 Inner 类定义在 Outer 类的内部，相当于 Outer 类的一个成员变量的位置，Inner 类可以使用任意访问控制符，如 public 、 protected 、 private 等

2、 Inner 类中定义的 test() 方法可以直接访问 Outer 类中的数据，而不受访问控制符的影响，如直接访问 Outer 类中的私有属性a

3、 定义了成员内部类后，必须使用外部类对象来创建内部类对象，而不能直接去 new 一个内部类对象，即：内部类 对象名 = 外部类对象.new 内部类( );

4、 编译上面的程序后，会发现产生了两个 .class 文件

其中，第二个是外部类的 .class 文件，第一个是内部类的 .class 文件，即成员内部类的 .class 文件总是这样：外部类名$内部类名.class

另外，友情提示哦：

1、 外部类是不能直接使用内部类的成员和方法滴

可先创建内部类的对象，然后通过内部类的对象来访问其成员变量和方法。

2、 如果外部类和内部类具有相同的成员变量或方法，内部类默认访问自己的成员变量或方法，如果要访问外部类的成员变量，可以使用 this 关键字。如：

运行结果：

什么是 Java 中的内部类

问：什么是内部类呢？

答：内部类（ Inner Class ）就是定义在另外一个类里面的类。与之对应，包含内部类的类被称为外部类。

问：那为什么要将一个类定义在另一个类里面呢？清清爽爽的独立的一个类多好啊！！

答：内部类的主要作用如下：

1. 内部类提供了更好的封装，可以把内部类隐藏在外部类之内，不允许同一个包中的其他类访问该类

2. 内部类的方法可以直接访问外部类的所有数据，包括私有的数据

3. 内部类所实现的功能使用外部类同样可以实现，只是有时使用内部类更方便

问：内部类有几种呢？

答：内部类可分为以下几种：

• 成员内部类

• 静态内部类

• 方法内部类

• 匿名内部类

类是对象的类型

Java对象：

使用对象的步骤：

1.创建对象

  类名 对象名 = new 类名();

  Telphone phone = new Telphone();

2.使用对象

  引用对象的属性：对象名.属性

  phone.screen = 5.1f;//给screen属性赋值5.1

  引用对象的方法：对象名.方法名()

  phone.sendMessage();//调用sendMessage()方法

注意：float型变量赋值时需要加f，否则默认浮点数是double型

类的定义步骤：

1.定义类名   public class 类名{}

2.编写类的属性

3.编写类的方法

注意：一个类中可以定义多个属性和方法

示例：

public class Telphone{

    //属性(成员变量) 有什么

float screen;

float cup;

float mem;

//方法 干什么

void call(){

    System.out.println("Telphone有打电话的功能");

}

void sendMessage(){

    System.out.println("Telphone有发短信的功能");

}

}

类：类是模子，确定对象将会拥有的特征(属性)和行为(方法)

类的特点：1.类是对象的类型，2.具有相同属性和方法的一组对象的集合

属性：对象具有的各种特征；每个对象的每个属性都拥有特定值

方法：对象执行的操作

对象是一个能够看得到、摸得着的具体实体

//外部类
public class HelloWorld {
   
    // 外部类中的静态变量score
    private static int score = 84;
    private int a=20;
    // 创建静态内部类
 public static  class SInner {
        // 内部类中的变量score
        int score = 91;
       
  public void show() {
   System.out.println("访问外部类中的score：" +   HelloWorld.score);
    System.out.println("访问外部类中的a：" +   new HelloWorld().a);
   System.out.println("访问内部类中的score：" + score);
  }
 }

 // 测试静态内部类
 public static void main(String[] args) {
  // 直接创建内部类的对象
        SInner si = new SInner();
       
        // 调用show方法
  si.show();
 }
}

//外部类HelloWorld
public class HelloWorld{
   
    //外部类的私有属性name
    private String name = "imooc";
   
    //外部类的成员属性
    int age = 20;
   
 //成员内部类Inner
 public class Inner {
  String name = "爱慕课";
        //内部类中的方法
  public void show() {
   System.out.println("外部类中的name：" +        HelloWorld.this.name          );
   System.out.println("内部类中的name：" +              name    );
   System.out.println("外部类中的age：" + age);
  }
 }
   
 //测试成员内部类
 public static void main(String[] args) {
       
        //创建外部类的对象
  HelloWorld o = new HelloWorld ();
       
        //创建内部类的对象
  Inner inn = o.new Inner();
       
        //调用内部类对象的show方法
  inn.show();
 }
}

public class HelloWorld {
   
    // 定义静态变量score1
    static int score1 = 86;
    // 定义静态变量score2
   static int score2 = 92;

    // 定义静态方法sum，计算成绩总分，并返回总分
 public  static   int sum() {
     //int score3=score1+score2;
      return score1+score2;
     
 }

 public static void main(String[] args) {
       
        // 调用静态方法sum并接收返回值
  int allScore = sum();
       
  System.out.println("总分：" + allScore);
 }
}

内部类MInner

【1】无返回值

public void print(){

    …………

}

MInner mi=new MInner();

mi.print();

【2】有返回值

public int getScore(){

    …………

}

MInner mi=new MInner();

int newScore=mi.getScore();

1.接口的概念

2.接口的定义

常量：接口中的属性是常量，  系统自动加上public static fanal修饰符 

方法：接口中只能是抽象方法，系统自动添加 public abstract修饰符

和类定义不同，不使用class关键字，使用interface关键字

可多继承

3.接口定义的基本语法

【修饰符】 abstract interface 接口名【extends 父接口1，父接口2...】

｛ 零个到多个常量定义... 零个到多个抽象方法的定义

             ｝   

4.使用接口

匿名内部类实现接口：只关心实现方法不关心方法的名字

方法内部类