Ⅰ.对象

1. 创建对象
①对象声明：
      格式：
             类的名字   对象名字

     People zhang;
②对象分配内存

zhang=new People();

 eg1:   class Point
        {
          int x,y;//变量的定义
          Point(int a,int b)//方法的定义
            {
               x=a;
               y=b;
             }
         }
        public class A
          {
             public static void main(String args[])
               {
                  Point p1,p2;//声明对象p1和p2
                  p1=new Point(10,11);//为对象分配内存，使用new和类中的构造方法
                  p2=new Point(12,13);
                }
           }

//如果没有提供不带参数的构造方法，如以下创建对象是非法的：p1=new Point();

③对象的内存模型

a:声明对象时的内存模型
     xiyoujirenwu zhubajie;
b:对象分配内存后的内存模型

   zhubajie=new xiyoujirenwu();

    系统看到此句后，会做两件事
   为height、weight、head、ear、mouth、hand、foot各个变量分配内存，即xiyoujirenwu
类的成员变量被分配内存空间，然后执行构造方法中的语句；给出一个信息，确保这些变量
是属于对象zhubajie的，即这些内存单元将由zhubajie操作管理；所谓为对象分配内存就是
指为它分配变量，并获得一个引用，以确保这些变量由它来“操作管理”。
  
对象的声明和分配内存两个步骤可以用一个造价的步骤完成：
    xiyoujirenwu zhubajie=new xiyoujirenwu();
c:创建多个不同的对象
    zhubajie=new xiyoujirenwu();
    sunwukong=nwe xiyoujirenwu();

2.使用对象
 
  ①对象操作自己的变量（对象的属性）
      通过使用运算符“.”，对象可以实现对自己的变量的访问。

  ②对象调用类中的方法（对象的功能）
　　　对象创建以后，可以使用运算符“.”调用创建它的类中的方法，从而产生一定的行
   功能；
      当对象调用方法时，方法中出现在的成员变量就是指该对象的成员变量；
      当对象调用类中的一个方法时，方法中的局部变量被分配内存这间，方法执行完毕，
   局部变量即刻释放内存，局部变量声明时如果没有初始化，就没有默认值，因此在使用
   局部变量之前，要事先为其赋值。

eg2:

 class xiyoujirenwu
{
 float height,weight;
 String head,ear,hand,foot,mouth;
 void speak(Strings)
 {
  head="歪着头";
  System.out.println(s)
 }
}
class A
{
 public static void main(String args[])
 {
  xiyoujirenwu zhubajie,sunwukong;//声明对象
  zhubajie=new xiyoujirenwu();//为对象分配内存
  sunwukong=new xiyoujirenwu();
  zhubajie.height=1.80f;//对象给自己的变量赋值
  zhubajie.head="大头";
  zhubajie.ear="一双大耳朵";
  sunwukong.height=1.62f;
  sunwukong.weight=1000f;
  sunwukong.head="秀发飘飘"；
     System.out.println("zhubajie的身高:"+zhubajie.height);
  System.out.println("zhubajie的头:"+zhubajie.head);
  System.out.println("sunwukong的重量:"+sunwukong.weight);
  System.out.println("sunwukong的头:"+sunwukong.head);
  zhubajie.speak("俺老猪我想娶媳妇");//对象调用方法
  System.out.println("zhubajie现在的头:"+zhubajie.head);
  sunwukong.speak("老孙我重1000斤，我想骗八戒背我");
  System.out.println("sunwukong现在的头:"+sunwukong.head);
 }
}

3.对象的引用和实体
     当用类创建一个对象时，类中的成员变量被分配内存空间，这些内存空间称为该对象的
  实体；
以eg1中的Point类为例
       假如分别使用类的构造方法Point(int x,int y)创建了两个对象p1、p2:
   Point p1=new Point(10,14);
   Point p2=nwe Point(11,4);
   //因此，一个类创建的两个对象具有相同的引用，那么就具有完全相同的实体。没有实体的对象
称为空对象，空对象不能使用，即不能让一个空对象去调用方法产生行为；假如程序中使用了空对象
程序在运行时会出现异常：NullPointException。（java 编译器对空对象不做检查，应尽量避免使用）。

4.参数传值
    
     当方法被调用时，如果方法有参数，参数必须要实例化，即参数变量必须有具体的值。方法中参
数变量的值是调用者指定的值的副本。

  a:基本数据类型参数的传值
      不可以向int型参数传递一个float值，但可以向double型参数传递一个float值。
  b:引用类型参数的传值
      java的引用型数据包括对象、数组以及接口。当参数是引用类型时，“传值”传递的是变量的
引用而不是变量所引用的实体 ；
      如果改变参数变量所引用的实体，就会导致原变量的实体发生同样的变化。因为两个同类型的
引用型变量如果具有同样的引用，就会用同样的实体。但是，改变参数的引用不会影响向其传值的变量
的引用。

eg3:
   
class People
{
 int money;
 void setMoney(int n)
 {
  money=n;
 }
}
class A
{
 void f(double y,People p)
 {
  y=y+1;
  p.setMoney(100);//对象调用方法
  System.out.println("参数y的值是:"+y);
  System.out.println("参数对象p的money是:"+p.money);
 }
}
public class B
{
 public static void main(String args[])
 {
  double y=0.8;
  People zhang=new People();
  zhang.setMoney(9999);
  A a=new A();//声明分配a
  System.out.println("在方法f被调用之前对象zhang的money是:"+zhang.money+"y的值是:"+y);
  a.f(y,zhang);//a 调用A中的方法
  System.out.println("在方法f被调用之后main方法中y的值仍然是:"+y);
  System.out.println("在方法f被调用之后main方法中对象zhang 的money是:"+zhang.money);
 }
}

Ⅱ.static关键字三四五六七八九
   一.实例变量和类变量的区别
    类体的定义包括成员变量的定义和方法的定义，并且成员变量又分为实例变量和类变量，用static修饰的
变量是类变量。
    不同的对象的实例变量将被分配不同的内存空间，如果类中的成员变量有类变量，那么所有对象的这个类
变量都分配给相同的一处内存，改变其中一个对象的这个类变量会影响其他对象的这个类变量，也就是说对象
共享类变量。

eg4:

class Takecare
{    static int x;
 int y;
}
class A
{ Takecare A1=new Takecare();
 Takecare A2=new Takecare();
}
     如果该类没有创建对象；类的实例成员变量不会被分配内存。
     如果该类创建对象，那么不同对象的实例变量互不相同，即分配不同的内存空间，而类变量不再重新分配内存，所有的对象共享类变量，即所有的对象的类变量时相同的一处内存空间，类变量的内存空间直到程序退出运行，才释放所占有的内存。

eg5：

class
{   float 上底,高;
    static float;
    梯形(float x,float y,float h)
    {上底=x;下底=y;高=h;
    }
    float 获取下底()
    {return 下底;
    }
    void 修改下底(float b)
    {  下底=b;
    }
}
class Example4_7
{public static void main (string args[])
  { 梯形 laderOne=new 梯形(3.0f,10.0f,20J),laderTwo=new 梯形(2.0f,3.0f,10);
   梯形.下底=200;      //通过类名操作类变量
   system.out.println("laderOne的下底: "+laderOne.获取下底());
   system.out.println("laderTwo的下底:"+laderTwo.获取下底());
   laderTwo.修改下底(60);      //通过对象操作类变量
   system.out.println("laderOne的下底:"+laderOne.获取下底());
   system.out.println("laderTwo的下底:"+laderTwo.获取下底());
}
}

二.实例方法和类方法的区别
   类体中的方法分为实例方法和类方法两种，用static修饰的是类方法，当一个类创建了一个对象后，这个对象就可以调用该类的方法。
    当创建第一个对象时，类中的实例方法就分配了入口地址，当再创建对象时，不再分配入口地址，也就是说，方法的入口地十被所有的对象共享，当所有的对象都不存在时，方法的入口地址才被取消。实例方法即可以操作实例变量也可操作类变量。
    类方法中出现的成员变量必须是被所有对象共享的变量，即类方法不可以操作实例变量，这样规定的原因是：在类创建之前，实例成员变量还没有分配内存。类方法也不可以调用其他的实例方法，这是因为在类创建对象之前，实例方法也没有入口地址。
    无论是类方法或实例方法，当被调用执行时，方法中的局部变量才被分配内存空间，方法调用完毕，局部变量即刻释放所占的内存。在一个方法被调用执行完毕之前如果该方法又被调用，那么，方法的局部变量会再次被分配新的内存空间。

eg5:
      class Fibi
      {    public static long fibinacii(int n)
           {   long c=0;
               if(n==1 || n==2)
                  c=1;
               else
                  c=fibinacii(n-1)+fibinacii(n-2);
                return c;
            }
      }
     public class Eg5
     {   public static void main(String args[])
          {  System.out.println(Fibi.fibinacii(7));

  Ⅲ.this关键字
    this是java的一个关键字，表示某个对象。this可以现在实例方法和构造方法中，但不可以出现在类方法中。this关键字出现在类的构造方法中时，代表使用该构造方法所创建的对象。实例方法必须通过对象来调用，当this关键字出现在类的实例方法中时，代表正在调用该方法的当前对象。
    实例方法可以操作类的成员变量，当实例成员变量在实例方法中出现时，默认的格式为：
      this.成员变量
    当static成员变量在实例方法中出现时，默认的格式为：
      类名.成员变量
eg:
      class A
      { int x,
        static int y;
        void f()
        {this.x=199;
         A.y=188;
         }
       }

//当实例成员变量的名字和局部变量的名字相同时,成员变量前面的"this."或"类名."就不可以省略。
   类的实例方法可以调用类的其他方法，对于实例方法调用的默认格式为：
       this.方法；
   对于类方法调用的默认格式为：
       类名.方法；
eg:
       class B
        {  void f()
           { this.g();//g前面的this.可以省略
             B.h();//h前面的B.可以省略
           }
          void g()
          { System.out.println("ok");       
           }
         static void h()
          { System.out.println("hello");
           }
          }
//this关键字不能出现在类方法中，这是因为，类方法可以类名直接调用；

Ⅳ.包
   一.包语句
     通过关键字package声明包语句：
                                  package  包名；（待续）