1 static关键字

1.1 概述

static是静态的意思;
static主要是用来修饰对象共享的数据.可以修饰变量,也可以修饰方法;
被static修饰变量和方法 是属于类,不属于对象;
成员变量和成员方法是属于对象,不属于类;

1.2 访问被static修饰的变量和方法

有两种方式:
1.通过对象名访问变量和方法
对象名.静态成员;
例如:Chinese c = new Chinese();
System.out.println(c.country);
不建议使用这种方法时来访问;
2.通过静态的方式访问
就是通过类名来访问:
类名.静态成员;
例如:
System.out.println(Chinese.country);

1.3 静态代码块

    静态代码块是在第一次使用类时被执行的,而且是最先被执行,优先于构造方法被执行;<br />        静态代码块只能被执行一次,就是在第一次使用类时被执行的;<br />        应用场景:<br />            主要用于初始化数据.<br />          比如:在类中使用静态代码块,初始化数据库的四个连接信息;

2 final关键字

final是最终的,不可修改的意思.

2.1 可以修饰类

    格式:<br />            修饰符 final class 类名{<br />                 ...<br />            }<br />        被final修饰的类不能被继承;

2.2 可以修饰方法

    格式:<br />            修饰符 final 返回值类型 方法名(参数列表){<br />                ...<br />            }<br />        被final修饰的方法不能被重写;

2.3 可以修饰变量

  定义常量的格式:<br />        修饰符 final 数据类型 变量名 = 初始值;<br />    变量的值以后就不能再改变了.其实就是在定义常量,上面的格式就是定义常量的格式<br />    如定义常量:<br />        final int  a = 100;<br />    如果在定义常量时没有给常量赋值,需要在每个构造方法中给常量赋值(每个构造方法中常量的值可以不一样);<br />在工作中,常量的名字一般用大写.<br />在工作中,常量尽量不要定义到类里面去,一般都把项目中用到的常量都定义到一个常量的工具类里面去,然后用的时候通过类名去调用常量.

3 包

包就是用来存储.class文件文件夹.
包可以对类进行分类管理;

3.1 包的命名规则

见名知意;<br />    有两种命名方式:<br />        最顶层的包名:<br />            [www.csdn.com](www.csdn.com)反写成com.csdn<br />        第一种:<br />            根据项目中模块的名字来给包命名<br />            mobile office-auto-->moa<br />            项目中最顶层的报名:<br />                    com.csdn.moa<br />            模块:<br />                用户管理: com.csdn.moa.user<br />                会议管理:com.csdn.moa.metting<br />                邮件管理:com.csdn.moa.mail<br />                .....<br />                工具类的包:com.csdn.moa.utils<br />        第二种:<br />            根据类的功能作用来给包命名:<br />                com.csdn.moa.bean/domain/entity: java bean<br />                com.csdn.moa.service:接口<br />                com.csdn.moa.service.impl:接口实现类<br />                com.csdn.moa.utils:工具类<br />                ....<br />    推荐第二种方式;

4 权限修饰符

访问权限:是用来控制类,方法,变量等的使用范围的;
四种访问权限的修饰符:
public(公共的,公用的) —> protected(受保护的) —> 默认的(default) —> private(私有的,专有的意思);
权限从左向右依次变小;
public权限最大,private的权限最小;

权限修饰符适用范围表格

    <br /> 归纳一下：在日常开发过程中，编写的类、方法、成员变量的访问<br />l  要想仅能在本类中访问使用private修饰；<br />l  要想本包中的类都可以访问不加修饰符即可；<br />l  要想本包中的类与其他包中的子类静态的可以访问使用protected修饰<br />l  要想所有包中的所有类都可以访问使用public修饰。<br />l  注意：如果类用public修饰，则类名必须与文件名相同。一个文件中只能有一个public修饰的类。

5 内部类

内部类: 一个类中定义在另一个类中,这个类就叫内部类;

class Outer{
        public int a = 10;
        public void show(){
            ...
        }
        class Inner{
            ...
        }
    }

在一个类中,只有一个类能被public修饰. 且 .java的名字要和class后面的名字一样.

5.1内部类的分类:

5.2.1.成员内部类

    内部类写在了外部类成员的位置;<br />        使用方式:<br />先创建内部类的对象,再通过内部类对象访问内部类中定义的变量或者方法;<br />            // 1.创建外部类对象的格式<br />                外部类名.内部类名 内部类对象 = new 外部类名().new 内部类名();<br />举例:

Outer.Inner inner = new Outer().new Inner();
然后通过inner来调用内部类中的变量或者方法

如何在内部类中调用外部类的方法和变量a?
情况1:
如果内部类中没有定义与外部类中一样的变量a, 可以直接在内部类中用(就相当于在外部类中继承过来的).
情况2:
如果内部类中定义了与外部类中一样的变量a,直接用的话访问的是内部类中的变量a.
如果此时想访问外部类中的变量a,可以用

外部类类名.this.a

这种方式来调用
方法用法与变量同理.

5.2.2.局部内部类

    定义在方法中的内部类(就是局部变量的位置);

public class Outer{
    public void show(){
        ...
        int a = 10;
        class Inner{
            ...
        }
    }
}

5.3 匿名内部类

没有名字的内部类.
使用条件:
匿名内部类不能单独存在;
要求在定义匿名内部类时,必须立即创建匿名内部类的对象;
要想创建匿名内部类的对象,要求必须有接口或者父类;
一般项目中

创建匿名内部类对象有两种写法:

1.有父类
创建的是子类的对象;子类没有名字,又是写在方法内部的,所有叫做匿名内部类;

//说明:Person类是Student类的父类,第8-13行表示创建了一个匿名内部类,15-20行表示创建了一个匿名内部类然后立即调用里面重写的eat方法
public class Person{
    public void eat(){
        System.out.println("===Person类==eat()========");
    }
}

new Person(){
    // 重写父类中的eat方法
    public void eat(){
    System.out.println("===匿名内部类==eat()========");
    }
};

new Person(){
    // 重写父类中的eat方法.
    public void eat(){
    System.out.println("===匿名内部类==eat()========");
    }
}.eat();

2.有接口
创建的是实现类的对象;实现类没有名字,又是写在方法内部的,所有叫做匿名内部类;

//说明:Animal是Cat类的接口,第6-11行表示创建了一个匿名内部类,13-18行表示创建了一个匿名内部类然后立即调用里面重写的eat方法
public interface Animal{
    public abstract void eat();
}

new Animal(){
    // 实现接口中的eat方法.
    public void eat(){
        System.out.println("===匿名内部类==eat()========");
    }
};

new Animal(){
    // 实现接口中的eat方法.
    public void eat(){
        System.out.println("===匿名内部类==eat()========");
    }
}.eat();

说明:代码块里不能写方法.