1：面向对象 

     面向对象的概念：

1）是基于面向对象的一种思想

2）将功能封装进对象，强调具备了功能的对象

3）面向对象时基于面向过程的

     面向对象特点：

1)面向对象就是一种常见的思想，符合人们的思考习惯；

2)面向对象的出现将复杂问题简单化

3)面向对象的出现，让执行者变成指挥者

     面向对象的三个特征：

封装，继承，多态

 2：成员变量和局部变量 

     成员变量和局部变量的区别：

1）定义位置的不同

a) 成员变量：定义在类内，方法外

b) 局部变量：定义在方法内

2）初始化值的不同

a) 成员变量：有默认初始化值

b) 局部变量：没有默认初始化值，必须进行初始化

3）存储位置的不同

a) 成员变量：存储在堆内存中

b) 局部变量：存储在栈内存中

4）使用的修饰符的差别

a) 成员变量：可以被各类修饰符修饰

b) 局部变量：只能被final修饰

5）生命周期不同

a) 成员变量：随着类的加载而加载，随着类的消失而消失

b) 局部变量：随着方法的使用而加载，随着方法的消失而消失

      成员变量的赋值方式：

1）直接在定义的时候

2）通过类名.成员变量名赋值

3）通过set方法赋值

4）通过构造函数对对象初始化时赋值

3：匿名对象

   格式：new 类名()

调用方式：new 类名().对象名();

特点：

1）只能使用一次

2）作为实参传递

代码体现：

class Student
{
    //成员变量
    public int age=10;
    public String name;//定义名字
    public void show()//建立一个函数用来显示年龄
    {
        System.out.println(age);
    }}

class AnonymityDemo 
{
    public static void main(String[] args) 
    {         
        Test t = new Test();//初始化
        //t.showStu(s);
        t.showStu(new Student());

/*调用函数并内置初始化，Student s=new Student();*/
  }}

class Test
{    //                    int    a
    public void showStu(Student s)//建立函数定义，实现功能；
    {
        s.show();//调用Student方法
}}

4：面向对象——封装

   封装：是指隐藏对象的属性和实现细节，仅对外提供公共的访问方式；

   封装的好处：

                 1）将变化隔离

                 2）便于使用

                 3）提高重用性

                 4）提高安全性

   封装的原则：将不需要对外提供的内容都隐藏起来，只提供公共的方法对其访问

5：关键字

Static关键字

作用：用于修饰成员（成员变量和成员方法）

被修饰后的特点：

1）随着类的加载而加载

2）优先于对象存在

3）可以直接被类名调用

4）被所有对象所共享

注意事项：

静态方法：

1）静态的方法只能被静态方法所调用

2）静态方法中不能有this，super关键字（由于他优先于对象而存在）

3）只能使用静态变量

4）被static修饰的成员其实是一个类成员

a) 当这个类第一次加载的时候，就会对该类分配内存空间

b) 当该类被创建实例时，并不会对该类变量的拷贝，而是多个类的实例 

共享该变量，且所有对象都可以操作这块内存空间；

 用途：静态方法常常为应用程序中的其他类提供一些实用工具，在java的类库中

       大量的静态方法正是出于此目的而定义的  

 静态变量：

   1） 可以使用“类名.方法名”直接调用

2） 可以被类中所有方法使用（static与非static）

3） 该类中的某一个对象修改了变量的值，其他所有该类对象中的对应值都会

  随之改变

4） 定义时初始化，或者通过静态代码块初始化

 静态变量与非静态变量的区别： 

1）两个变量的生命周期不同

成员变量：随着对象的创建而存在，随着对象的被收回而释放

静态变量：随着类的加载而存在，随着类的消失而消失

2）调用方式不同

成员变量：只能被对象调用

静态变量：可以被对象调用，也可以类名.静态变量调用

3）别名不同

成员变量：称为实例变量

静态变量：类变量

4）存储位置不同

成员变量：存储在堆内存的对象中，所以也叫对象的特有数据

静态变量：存储在方法区的静态区，对象的共享数据

private关键字 

1）是一个访问权限修饰符，表示私有意义。

2）用于修饰成员(成员变量和成员函数)

3）被私有化的成员只在本类中有效。

this关键字

特点：

this关键字代表所属函数的所属对象的引用

   适用范围：

1） 局部变量隐藏全局变量之中

2） 构造函数中使用

super关键字

特点：代表父类内存空间的标识

适用范围：

1） 当子父类重名时区分

2） 子类要调用父类的构造方法

final关键字

1）final可以修饰类，方法，变量。
2）final修饰的类不可以被继承
3）final修饰的方法不能被覆盖或重写；
4）final修饰变量时该变量是常量不能被赋值；
5）final修饰的常量只能被赋值一次
6）内部类只能访问被final修饰的局部变量；

特点：
     1. 用final修饰的变量表示常量，只能被赋一次值，不能修改。
          final修饰的成员变量没有默认初始化值，需要显式初始化
          final修饰的基本类型变量：值不能被修改
          final修饰的引用类型变量（对象）：对象地址不能被修改，对象内部

       的成员可以被修改
         被定义为final的对象引用只能指向唯一一个对象，不可以将它再指向其他对象，但是一个对象内部的 值却是可以改变的。
         被final修饰的变量是一个常量，必须被赋值后才能使用。可以在定义时赋值，也可在构造方法中赋 值。（只要在构造方法结束前给赋值就OK。）
     2. 用final修饰的方法不能被子类的方法覆盖
     3. 用final修饰的类不能被继承，没有子类；
        final类不能被继承，因此final类的成员方法没有机会被覆盖，默认    都是final的。
      但是final类中的成员变量可以被定义为final或非final形式。
        在设计类时候，如果这个类不需要有子类，类的实现细节不允许改 变，那么就设计为final类。
     4. final不能用来修饰构造方法。
    示例：
    3.
    public class Something {
       public int addOne(final int x) {
           return ++x;
       }
    }
    4.
    public class Something {
       public static void main(String[] args) {
           Other o = new Other();
           new Something().addOne(o);
       }
       public void addOne(final Other o) {  //o= 0x1234;
           o.i++;
       } }
static和final
    static final用来修饰成员变量和成员方法，可简单理解为“全局量”！ 
    对于变量，表示一旦给值就不可修改，并且通过类名可以访问。 
    对于方法，表示不可覆盖，并且可以通过类名直接访问。。

Math关键字

 主要方法：Math.random