java封装jichu

package Javabasic;
/*this关键字
 * 1.构造函数变量同名时使用
 * 2.this的应用
 * 在定义类中的功能（函数）时，该函数内部要调用该函数的的对象，这时用this表示这个对象
 * 但凡本类功能内部使用了本类对象，都要用this
   3.构造函数间的调用this();只能放在第一行

class Person
{
 private int age;
 private String name;
 
 Person(int age)
 {
  this.age=age;
  show();
 }
 Person(int age, String name)
 {    
  this(age);
  //this.age=age;
  this.name=name;
  show();
 }
 public void show()
 {
  System.out.println("age="+this.age+",name="+this.name);
 }
}
public class Day3
{
 public static void main(String[] args)
 {
  Person p1=new Person(20);
  Person p2=new Person(21,"zhangsan");
 }
 
}*/
/*class Person
{
 int age;
 String name;
 Person(int age,String name)
 {
  this.age=age;
  this.name=name;
  this.show();
 }
 public void show()
 {
  System.out.println("age="+this.age+",name="+this.name);
 }
 //比较年龄是否相等
 public boolean compare(Person p)
 {//this是对象的引用，哪个对象调用方法this就代表哪个对象
  return this.age==p.age;//该函数内部要调用该函数的的对象，这时用this表示这个对象
 }
 
}
public  class Day3
{
 public static void main(String[] args)
 {
  Person p=new Person(20,"zhangsan");
  Person p1=new Person(20,"lisi");
  boolean b=p.compare(p1);
  System.out.print(b);
 }
}
*/

 

 

 

/*
 * 构造函数&&构造代码块
 * 1.特点，函数名与类名相同，没有返回值（也就没有return）
 * 2.作用：给对象进行初始化
 * 3.注意：对象一建立就会调用与之对应的构造函数
 *         小细节：当一个类中没有定义构造函数，系统会默认加入一个空参数的构造函数
 * 4.构造函数与一般函数的区别
 *  构造函数在对象一建立，就运行，给对象进行初始化，构造函数只运行一次
 *   一般函数是在对象调用才执行，可以被对象多次调用
 * 5.什么时候使用构造函数
 *  对象一存在就具备的一些内容，这些内容定义在构造函数中，构造函数可以有多个，用于给不同的
 *  对象就行针对性的初始化
 * 6.构造代码块 作用：给对象初始化；对象一建立就会运行且优先于构造函数
 *   与构造函数的区别：构造代码块是给所有的对象初始化，而构造函数是给对应的对象初始化
 *   构造代码中定义的是不同对象的共性内容
 * */
/*class Person
{
 private String name;
 private int age;
 
 {
  System.out.println("cry......");//构造代码块
 }
 Person()
 {
  System.out.println("A:name="+name+","+"age="+age);
  //cry();
 }

 
 Person(String name)
 {
  this.name=name;
  System.out.println("B:name="+name+","+"age="+age);
  //cry();
 }
 public void setName(String name)//修改
 {
  this.name=name;
 }
 public String getName()//获取
 {
  return name;
 }
 Person(String name,int age)
 {
  this.name=name;
  this.age=age;
  System.out.println("C:name="+name+","+"age="+age);
  //cry();
 }
 public void cry()
 {
  System.out.println("cry.......");
 }
 
}
public class Day3
{
 public static void main(String[] args)
 {
  Person p=new Person();//对象会调用与之对应的构造函数
  Person p1=new Person("lisi");
  //System.out.println(p1.getName());
  //p1.setName("libusi");
  //p1.setName("还是libusi");
  //System.out.println(p1.getName());
  //Person p2=new Person("wangwu",10);
 }
}
*/

 

 

/*private 私有，权限修饰符，用于修饰类中的成员（变量，函数），私有 只在本类中有效
 注意：私有仅是封装的一种表现形式
 1.将age私有后，类以外即使建立了对象也不能直接访问,只能对外提供访问的方法void setAge(int a)和int getAge()
 2.之所以提供对外访问的方法，就因为可以在访问方式中加入逻辑判断等语句
 *
class Person
{
 private int age;//将age私有后，类以外即使建立了对象也不能直接访问,只能对外提供访问的方法
 
 public void setAge(int a)//之所以提供对外访问的方法，就因为可以在访问方式中加入逻辑判断
 {
  if(a>0&&a<130)
  {
   age=a;
   speak();
  }
  else
   System.out.println("哥们不对吧");
 }
 public int getAge()
 {
  return age;
 }
 void speak()
 {
  System.out.println("age="+age);
 }
}

public class Day3
{
 public static void main(String[] args)
 {
  Person p=new Person();
  //p.age=12;
  p.setAge(100);
  //p.speak();
 }
}
*/

 

 

 

/*class Car
{
 int num=4;
 String color="red";//描述颜色
 void run()
 {
  System.out.println(num+"-----"+color);
 }
}
public class Day3 {
 public static void main(String[] args)
 {
  //类类型的变量car指向new Car(),这个对象
 /* Car car=new Car();//new在堆类存产生一个实体
  
  car.color="blue";
  car.run();
  Car car1=new Car();
  car1.run();
  new Car(). color = "blue";
  new Car().num=5;
  new Car().run();
  Car c=new Car();
  show(new Car());//匿名对象
 }
 public static void show(Car c)
 {
  c.color="black";
  c.num=5;
  c.run();
 }
}*/