//写代码一定要保存，不然总是会报错，还查不出来，切记！当保存成为习惯就没有这个问题了
 * 面向对象：三大特点（封装，继承，多态），。这只是面向对象的，java的特点有很多，可移植，健壮，
 * 
 * 
 * 在多个对象中抽象出来的叫类
 * return 就是一个程序的结束，后面跟的逻辑都是无意义的，main是开始
 *  但程序进入main之前会先找static 然后把带有static的方法和变量放到静态池 静态池是在方法之前编译 
 * 
 * 生物：动物 植物 细胞  对于动植物来说   生物就是类   类下面有三种对象
 * 
 * 对象是类的实例   是一类事物的具体体现
 * 
 * 在类中的位置不同  
 * 成员变量：类中，方法外 
 * 局部变量：方法中 
 * 作用范围不一样  
 * 成员变量：类中 
 * 局部变量：方法中 
 * 初始化值的不同  
 * 成员变量：有默认值 
 * 局部变量：没有默认值。必须先定义，赋值，
 *  生命周期不同 
 *  成员变量：随着对象的创建而存在，随着对象的消失而消失 
 *  局部变量：随着方法的调用而存在，随着方法的调用完毕而消失 
 * 
 * 属性：成员变量：事物的状态信息
 * 方法： 成员方法：对应事物的行为
 *  
 * 类的使用
  方法的命名：修饰符  +  返回值类型   +方法名(数据类型 ){    }
  类的命名：    修饰符  +            +方法名     (  )   {    }
  变量       ：    修饰符  +  变量名
JavaBean是类的规范 ：必须是具体的，公共的 具有无参构造();写了有参，若不写无参，默认无参就不在生效

java中构造方法指的是：与类名相同，无返回类型的方法，参数可以为空，也可以带参数。
比如一个 Point 类，private Point(){}这个就是无参数的构造方法。
private Dao(int x0, int y0){}这个就是带参数的构造方法。
作用：用来初始化 java 类，提供类的初始化和实例化，即可以通过new来创建对象以便调用。
如果想在实例化对象的时候就为这个属性赋值的话，可以通过有参构造实现。


public:对所有类可见  

protected:对同一包中的类可见、对同一包及不同包中的子类可见

default:对同一包中的类可见、对同一包中的子类可见

private:仅对类本身可见   封装 修饰成员变量被   
private修饰后的成员变量和成员方法，只在本类中才能访问

可见是可访问的意思，即由这些修饰符修饰的成分（类、方法、成员变量）可以被其它类
访问。对子类可见即子类可以继承。

这里需要注意的是protected与default，二者的区别在于不同包中的子类是否可以继承。

封装的构造方法
 修饰符 当前类名(参数列表){
// 方法体    
}
 
 public class Animal(){   //创建一个类
 private int num;         //定义两个私有变量
 private String name;
 public Animal(){         //构建无参
 }
 public Animal(int num,String name){  //构建有参
 this.num=num;
 this.name=nume
 }
 public int getNum(int num){

 return num;
 }
 public void setNum(){
 this.num=num;
 }
 public void cont(){                 //创建方法
 }                                   
 
 }



 public class Cat (){
 public static void main (String [] args){

 }
 
 public String getName(){
     //Animal类的句柄     miao是类的对象     new Animal()  :Animal类的空间
 Animal miao=new Animal();      //创建一个Animal对象   miao  需要用到无参构造
 miao.setNum(" mao111");    //私有后的赋值  不私有可直接调用   miao.num=45;
 
 //调用的三种形式：直接调用，赋值调用   输出调用
 类中 ： 方法名直接调用
 赋值调用：int sum =getSum(5,6);使用有参构造
 输出调用：syso("有返回值得方法名()");
 重载：同一个类， 方法名相同 型参不同
 重写：子类重写父类中的抽象方法，声明完全一样，增加方法体；子类重写方法权限(public 等
 )必须大于父类
 
 子类初始化，默认先初始化父类的构造super();父类构造   super父类的引用  this没有继承关系也有本类引用的意义
 object 是所有类的爸爸  this.成员变量  this.成员方法  本类的成员变量和方法
 子类重写父类的构造，实例的调用就可以用父类的构造 若想使用子类的，还有重载，再次构造一个生成器
 super()  this()  都必须在第一行
 继承只能单继承
 但clss A{
 	class B extends A{
 		class C extends B{
 		}
 	}
 }   这样多层继承就可以解决单一继承的缺点
 abstract 抽象方法  的关键字，但接口的抽象类可以省略
 
 
 
 

 
 
 
 
                                                      
 
 
 
 }
 
 }

 
 
java中四种访问修饰符 



Java中的四种访问修饰符：public、protected、default（无修饰符，默认）、private。

 
•四种修饰符可修饰的成分（类、方法、成员变量）

			  public protected default private 
		  类         √       ×         √          ×
	            
  
                方法        √       √         √          √
 
               成员变量   √       √         √          √
 

 
•四种修饰符的访问权限

public:对所有类可见

protected:对同一包中的类可见、对同一包及不同包中的子类可见

default:对同一包中的类可见、对同一包中的子类可见

private:仅对类本身可见   

可见是可访问的意思，即由这些修饰符修饰的成分（类、方法、成员变量）可以被其它类访问。对子类可见即子类可以继承。

这里需要注意的是protected与default，二者的区别在于不同包中的子类是否可以继承。

访问权限 类 同一包 同一包中的子类 不同包中的子类 不同包 
public 
√
 
√
 
√
 
√
 
√
 
protected 
√
 
√
 
√
 
√
 × 
default 
√
 
√
 
√
 × × 
private 
√
 × × × × 

 
•例如

package1：ParentClass、ChildClassOne、TestOne

package2：ChildClassTwo、TestTwo

package3：TestThree

其中ParentClass为

public class ParentClass {

	public int a=2;
	protected int b = 3;
	int c = 4;
	private int d = 5;

}


　　1.对于TestOne来说，ParentClass类、a、b、c均可见，d不可见。即在TestOne中可以new一个ParentClass对象，且该对象中的a,b,c变量可操作。如下：

 

public class TestOne {

	public static void main(String args[]) {

		ParentClass obj = new ParentClass();

		System.out.println(obj.a);
		System.out.println(obj.b);
		System.out.println(obj.c);
//		System.out.println(obj.d);     //d 不可见
	}
}


　　2. ChildClassOne继承ParentClass且与其在同一个包中，则a、b、c均可见，d不可见。

public class ChildClassOne extends ParentClass{

	public static void main(String args[]) {

		ChildClassOne obj = new ChildClassOne();

		System.out.println(obj.a);
		System.out.println(obj.b);
		System.out.println(obj.c);
//		System.out.println(obj.d);      // d不可见
	}
}


　　3. ChildClassTwo继承ParentClass，则a、b均可见，d不可见，由于子类与ParentClass不在同一包中，故c（default类型）不可见。

public class ChildClassTwo extends ParentClass{

	public static void main(String args[]) {
		ChildClassTwo obj = new ChildClassTwo();

		System.out.println(obj.a);
		System.out.println(obj.b);
//		System.out.println(obj.c);    // c不可见
//		System.out.println(obj.d);    // d不可见
	}
}


　4.对于TestTwo来说，ParentClass类、a均可见，b、c、d不可见。由于TestTwo与ParentClass不在同一个包中，故只有public修饰的成分可见。

public class TestTwo {

	public static void main(String args[]) {

		ParentClass obj = new ParentClass();
		System.out.println(obj.a);
//		System.out.println(obj.b);     // b 不可见
//		System.out.println(obj.c);     // c 不可见
//		System.out.println(obj.d);     // d 不可见
	}
}


　
•另外值得注意的是继承父类的子类与其他类之间的可见性，取决于其他类与父类之间的可见性。

对于TestOne来说，ChildClassOne中a，b，c都可见，d不可见，这是由于TestOne与ParentClass在同一个包中。

而对于TestThree来说，ChildClassOne中只有a可见，这是由于TestThree与ParentClass在不同的包中。

需要注意：

虽然a、b对ChildClassTwo可见，TestTwo与ChildClassTwo在同一包中，

但对于TestTwo来说，ChildClassTwo中只有a可见，这是由于TestTwo与ParentClass在不同的包中，只有public修饰的可见。

 * 
 * 
 * 
 * 
 * 
 * 
 * 
 * 
 * */