1.Java 对象和类

类：它是抽象出一类事物的行为和状态。类是一个模板，用于创建具体实例（对象）的数据类型，类所声明的变量称作对象
对象：对象是类的一个实例，对象的状态就是属性，行为通过方法体现

1. 类的定义：包括类的声明和类体的内容

1. 类的声明：用到class关键字，class 类名{类体的内容} 类名首字母要大写，要见名知意
2. 类体的内容：包含 变量的声明和方法的定义
   （1）变量的声明：称作成员变量 在整个类中都有效
   （2）方法的定义：类比于C语言中的函数的定义：
   方法头：方法的类型 名称 （形参列表）
   方法体中声明的变量和形参，称作是局部变量

2. 构造方法：

在创建对象时，用来初识化该类中的对象

1. 构造方法的名字必须和它所在的类的名字完全相同
2. 构造方法没有类型（返回类型）
3. 允许在一个类中编写若干个构造方法，但他们的参数不同
   （1）参数的个数不同 （2）个数同，但参数列表中对应的某个参数类型不同
   又分为无参和有参的构造方法，一般都写
4. 若类中没有写构造方法，系统默认该类只有一个构造方法：无参数，方法体中无语句；但若类中定义了一个或多个构造方法，就不提供默认的构造方法

3. 创建对象

包括：

（1）对象的声明： 类名 对象名；

（2）为声明的变量来分配变量：使用new运算符和类的构造方法

解释：内存模型：

public class Xi {//定义一个Xi类
	float h;
	String w;
	void speak(String s) {//方法
		System.out.println(s);
	}
	public static void main(String[] args) {
		Xi dx = new Xi(); 
	}
}

1. 执行new Xi()；时，会为该Xi类中的成员变量h 和w分配内存空间
2. 执行构造方法中的语句；此时没有构造方法，系统提供默认的构造方法：
   Xi(){}
   若成员变量在声明的时候没有赋初值，在构造方法中也没有赋初值；那他会有默认值：整型：0 浮点型：0.0 布尔型：false 引用型：null

new 运算符在为成员变量分配内存后，将计算出一个称为引用的值（包含了这些成员变量的内存位置和相关的信息）就是指new Xi()是一个十六进制的数值
4. dx = new Xi(); 执行赋值语句，将引用给了对象dx,对象就可以操作管理这些变量
new 运算符只和类的构造方法进行计算得出一个引用，再赋值给对象，则对象就拥有了被new 运算符分配了内存的成员变量

4. 访问对象的变量和方法

1. 成员变量又可以分为实例变量和类变量（静态变量）

1. 类变量就是在变量的类型前面加上static 例如：static int a;
2. 此类不同的对象的实例对象不相同，占用不同的内存空间
3. 此类所有对象共享类变量，占用相同的内存空间，改其中一个对象的类变量，其他对象的类变量也随着改变
4. 通过 对象. 来访问实例变量
5. 通过 类名. 来访问类变量

2.除构造方法外，方法又分为实例方法和类方法（静态方法）

1. 通过 对象. 来调用实例方法
   因为只有该类创建对象后，类中的实例方法才分配入口
2. 通过 类名. 来调用类方法
   因为该类被加载到内存，类中的类方法就分配了入口

public class Puppy{
   int puppyAge;
   public Puppy(String name){
      // 这个构造器仅有一个参数：name
      System.out.println("小狗的名字是 : " + name ); 
   }
 
   public void setAge( int age ){
       puppyAge = age;
   }
   
   public int getAge( ){
       System.out.println("小狗的年龄为 : " + puppyAge ); 
       return puppyAge;
   }
   
   public static void main(String[] args){
      /* 创建对象 */
      Puppy myPuppy = new Puppy( "tommy" );
      /* 通过方法来设定age */
      myPuppy.setAge( 2 );
      /* 调用另一个方法获取age */
      myPuppy.getAge( );
      /*你也可以像下面这样访问成员变量 */
      System.out.println("变量值 : " + myPuppy.puppyAge ); 
   }
   //小狗的名字是 : tommy
    小狗的年龄为 : 2
    变量值 : 2

5. 访问修饰符

定义：用来表示对象是否可以通过 . 点运算符来操作自己的变量和用类中的方法

1.私有变量和私有方法（常用）

指的是：用关键字private来修饰的变量和方法
当在另一个类中创建了该类的对象后，对象不可以访问自己的私有变量和调用自己的私有方法（也不可以用类名去访问私有的类变量和私有类方法）

2. 共有变量和共有方法（常用）

指的是：用关键字pulic来修饰的变量和方法
在任何一个类中创建了该类的对象后，对象都可以访问自己的共有变量和调用自己的共有方法

3. 受保护的变量和方法

指的是：用关键字protected来修饰的变量和方法
当在另一个类中创建了该类的对象后，当两个类在同一个包中，对象可以访问自己的protected变量和方法

4.友好变量和友好方法

指的是：没有用关键字来修饰的变量和方法，当在另一个类中创建了该类的对象后，当两个类在同一个包中，对象可以访问自己的友好变量和方法

5.pulic类和友好类

不可以用protected和private来修饰类

1. 在类声明时，在class前加上pulic，得到一个pulic类，就可以在任何一个类中使用public类来创建对象
2. 不用public修饰的类称作友好类，在另一个类中使用该友好类创建对象时，要保证他们在同一个包中

6.关于实例和静态的总结

1.关于实例和静态：

package review;

public class review1 {
	public void m1() {}
	public void m2() {}
	public static void m3() {}
	public static void m4() {}
	public static void main(String[] args) {
		 //m1();
		 //m2();
		 m3();
		 m4(); 
		/*发现m1,m2不可以，m3,m4可以
		 * 分析：
		 * 1.main方法是静态的，java虚拟机JVM调用main方法时，直接采用“类名.”,所以静态方法中没有this;
		 * 2.m1(),m2()方法是实例方法，要通过“引用.”的方式去访问
		 * 3.m3(),m4()编译器会自动识别他们是静态方法，结果是“类名.m3()”
		 * 4.若想访问m1,m2方法，必须先创建对象*/
		  review1 a=new review1();
		  a.m1();
		  a.m2();
	}
	public void m5() {
		m1();
		m2();
		m3();
		m4();
	}
/*分析：
 * m5()是实例方法，执行这个方法的过程中，当前对象是存在的；
 *检测到m1(),m2()是实例方法，会在方法前自动加上“this.”
 *检测到m3(),m4()是静态方法，会在方法前自动加上“类名.”
 *以上的前提是，方法在同一类中
 * */
	int a=100;
	static int b=20;
	public void m6() {
		int c=1;
		 System.out.println(a);//系统自动识别为"this.a"
		 System.out.println(b);//识别为"review1(类名).b"
		 System.out.println(c);//局部变量访问时不需要"xxx."的，在方法体内定义的局部变量，直接访问即可
	}
	public  static void m7() {
		int c=1;
		review1 s=new review1();
		System.out.println(s.a);
		// System.out.println(a);静态中没有this,必须先创建对象
		 System.out.println(b);//识别为"review1(类名).b"
		 System.out.println(c);
	}
	
	/*以下是在不同类中，调用另一个类中的方法时,想调用T类中的t1()和t2()方法时，
	 * 可以直接t1();t2();吗？
	 * 
	*/
	public  static void m8() {
		T.t1();//在静态方法中访问另一个类中的静态方法，用类名.
		T a=new T();
		a.t2();//在静态方法中访问另一个类中的实例方法
		
	}
     public void m9() {
    	 T.t1();//在实例方法中访问另一个类中的静态方法，用类名.
		T a=new T();
		a.t2();//在实例方法中访问另一个类中的实例方法
	}
}


//以下是在不同类中，调用另一个类中的方法时
class T{
	public static void t1() {
	}
	public void t2() {	
	}
}

固定规律：所有的实例相关的都是先创建对象，通过“ 引用. ”来访问，所有静态相关的通过”类名 .“来访问

1.负责调用的方法a和被调用的方法b在同一个类中，才会出现"类名."和"this."可以省略的

2.若跨类调用，不论a是静态或者实例，b中的静态要"类名." 实例要先用b类创建对象，再用“对象.”去调用

7.包 package

1. 不同的Java源文件中两个类名字相同时，就可以让他们隶属于不同的包来区分
2. 使用关键字package来声明包语句：package 包名；
3. 作为源文件的第一条语句，指定义的类所在的包
4. 若没有package语句，称为无名包，在Eclipse中称作default package;

8. import语句

1. 若一个类想使用的类不和它在同一个包中，就会用到import语句
2. 一个Java源程序中可以有很多个import语句，它们必须写在package语句和源文件的类的定义之间
3. 想使用类库中已存在的类直接引入用，但像java.lang包中的类直接使用，不需要引入，例如System类，Math类