数据模型分析：1通过对现实世界的事与物主要特征的分析、抽象，为信息系统提供存取的数据结构以及相应的约束

数据结构组成：操作（方法）、属性

项目分析：1数据模型分析

                 2业务模型分析

                 3显示和流程分析

UML就是统一建模语言或者标准建模语言

多态基于继承的基础上，即两个类有继承关系。

public class Dog{} extends Animal    其中Animal为父类，Dog为子类。

引用多态：

1. 父类的引用指向本类对象

   Animal obj1 = new Animal();

2. 父类的引用指向子类对象

   Animal obj2 = new Dog();

方法多态：

1. 创建本类对象时，调用本类方法

2. 创建子类对象时，调用子类重写方法或者继承方法
   

引用多态和方法多态

Object.getClass()    返回一个类对象，描述的是一个类的信息，包括属性，方法，代码等等。

new Dog();   返回的是一个Dog类的对象，描述的是一个具体对象的信息。

this.getClass() == Object.getClass()  判断的是两个类是否为同一个类型。

//定义一个类

public class Telphone{

//属性（成员变量）有什么

float screen;

float cpu;

float mem;

int var;

//方法 干什么

void call(){}

//定义一个名叫call的方法 没有返回值

system.out.println("var:"+var);

system.out.print("Telphone有打电话的功能！")；

}

void sendMessge(){

System.out.println("screen:"+screen+"cpu":+cpu+"mem:"+mem+"Telphone有发短信的功能！")

  }

}

成员变量 局部变量；

成员变量在类中定义，用来描述对象将要有什么；

变量1类型 变量1；

局部变量在类的方法中定义，在方法中临时保存数据；

public 返回类型 方法1（）{

变量4类型 变量4；

}

final修饰类，则该类不能被继承 final修饰方法，则该方法可以被继承，但不能被覆盖（重写）

final修饰属性，则该属性在定义时需要初始化，或者在构造方法中初始化（二选一初始化） 

final修饰变量，该变量只能进行一次赋值（包括初始化），而后值不可更改，相当于常量

使用对象的步骤：

1. 创建对象：类名 对象名=new 类名（）；

   Computer lenovo=new Computer();

2. 使用对象：

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

   lenovo.screen=14;

   引用对象的方法：对象名.方法（）

   lenovo.work();

1. java程序都以class（类）为组织单元；

2. 类的组成：属性和方法

3. 定义类的步骤

   a.定义类名：public class 类名{}

   b.编写类的属性：属性n的类型 属性n；

   c.编写类的方法：方法n；

4. package com.play;

   public class Computer(){

   double screen;

   double cpu;

   double mem;

   void work(){

   System.out.println("可以工作")；

   void palyGames(){

   System.out.println("可以玩游戏");

   }

   }

   }

Question:

为什么要区分静态和非静态？

Answer:

一般静态变量都是公用的、全局的，程序一启动就会在内存开辟一块空间，存放它们。静态的不必实例化就能直接使用，是说在没有生成任何对象时就能运用该方法，所以静态方法里不能对非静态的成员变量做操作。一般静态方法操作静态成员变量或全局变量。

要搞清楚这个问题，我们需要清楚他们之间有什么区别，有什么优势和劣势。

首先看看静态与非静态方法的区别：

静态方法　　　　　　　　　　　　　　　　　 　 |  实例方法

1、静态方法可以通过“类.方法()”调用 　 　　　　 | 要在对象实例化后使用对象调用

2、只能使用静态变量和局部变量　　　　　　　　| 所有变量都可以使用

3、静态方法不能被子类重写　　　　　　　　　　| 实例方法可以

4、接口不能定义静态方法　　　　　　　　　　   | 实例方法可以

从上面区别来看，静态方法只有一个优势，就是调用的时候不用实例化，其他情况下跟实例方法相比都是处于劣势。那么我们在什么情况下会使用到静态方法？相信大家第一时间会想到一样的东西，工具类Util。工具类给我们开发带来了大大的方便，归根到底是“不用实例化就能用”的功劳。这是静态方法的一个优势。

而静态方法的劣势也很明显，局限性很大，不能重写，不能引用普通变量，接口不能定义等等。。。可能还有很多我没列举出来。

那究竟什么时候该用静态方法？我们就要最大化利用其优势而避其缺点：

1、一个方法完成一个独立的功能，而且不会干扰到其他方法或变量，则即使删掉这个方法，对其他东西都没有任何影响。

2、不依赖构造方法，不依赖接口，不依赖继承。（这也是为什么越学面向对象，越会纠结这个问题）

举个例子：String类即使删掉 static valueOf(Object obj)方法，也不会影响实例方法chatAt(int index)的使用。当然它可能会影响其他重载的valueOf方法。

至于现在网上很多资料都有一个误区，就是说静态方法一开始加载，会占用内存，而实例方法不会。这个说话其实是错误的，它们都是一样一开始就会加载，而且只会占用一份内存。因为方法不是变量，它只需要有一份内存就够了。而变量则不一样

-----------------------------------------------------------------------------------------------------------------------------------------------------------

下面来看看静态变量与非静态变量

静态变量　　　　　　　　　　　　　　　　　 　 |  非静态变量

1、可以通过“类.变量”来引用。　　　　　　　　  | 只能通过实例对象来引用。

2、程序运行时分配内存　　　　　　　　　　　　|  类实例化时分配内存。

3、只有一份内存被分配　　　　　　　　　　　　|  有多少个类被实例化，就有多少个该类的变量那么多份内存被分配。

4、静态变量定义后必须声明初始化　　　　　　   | 非静态变量可以延迟初始化。

其他.....

很明显，静态变量拥有的优势不少，第一点不用说。第2、3点可以利用它来做一个整个程序的全局变量，因为任何修改都只会指向同一份内存。

而第3点优势恰好就是我们的“饿汉式单例模式”的一个最简单的实现。

方法内部类只在外部类该方法的内部可见，且不能使用访问控制符（public, private, protected）和static修饰符。

1. equals()方法

   比较的是对象的引用是否指向同一块内存地址。

2. 要比较两个对象的属性值是否相等，要重写equals方法。

3. 类对象一般指的是属性，类的对象一般指的是属性值。