java之5天 面向对象

1.面向对象的特征

封装  继承 多态

以后的开发,其实就是找对象使用,没有对象,没有对象就创建一个对象

找对象, 建立对象, 使用对象,维护对象的关系

类和对象的关系

类就是:现实生活中实物的描述
对象:就是这类事物,实实在在的个体


比如: 张三 李四 
使用 java 类的描述 就是  
属性 (成员变量): 姓名   年龄  性别   
行为 (成员方法): 走路   学习  吃饭  睡觉  


成员变量:  作用于  整个类中  存在于  堆内存中
局部变量:  在栈内存中 


在描述下  Car
汽车总工程师          [图纸]

工人        汽车      汽车            汽车

可以看出 图纸中 规定了  汽车这一类个体  每个部件的参数 等信息

使用java来表示 
class  Car{    //图纸 

// (成员)属性 
   String  color="red";   //汽车有颜色,  工程师 规定这批次的 车的颜色默认为 红色
   int  num=4;     // 工程师规定  这批次的 车 有4个轮子 


//(成员)方法

  void run(){  

   System.our.println(color+"色的"+num+"轮车在跑!");

  }

}


//工人 专门根据 图纸 造对象
class  CarDemo{

    public static void mian(String [] args){
            Car c2=new Car();
            c.run();   // red色的4轮车在跑

            Car  c3=new  Car();
            cl.color="yellow";   //工程师打来电话说 这辆车 要改成 黄色 
            c1.run();     // yellow 色的4轮车在跑


           //对象的引用
           Car c=new Car();
           c.num=5;
           Car c1=c;
           c1.color="black";
           c.run();   //   

    }


}

[img]http://dl.iteye.com/upload/attachment/0081/9819/ab266263-0e3a-3d8a-b7b8-82c2838ab272.png[/img]


匿名对象

匿名对象   
    new  Car();
    new  Car().num=5;
    num  Car().color="green";

//匿名对象使用方式一:  当对对象的方法 调用一次时,可以使用匿名对象来完成,这样写比较简化.
//如果一个对象尽心多个成员调用,必须给这个对象起个名字.

//匿名对象使用方式二: 可以将匿名对象作为实际参数进行传递.

//需求 ,汽车修配厂,对汽车进行改装,将来的车改成黑色, 三个轮胎 .


Car  q=new Car();
update(q);

public  static void update(Car c){
  c.color="black";
  c.num=3;
  c.run();

}

实名对象的使用
[img]http://dl.iteye.com/upload/attachment/0081/9830/812be131-fcab-303f-8076-828c7785d1b6.png[/img]

匿名对象的使用
[img]http://dl.iteye.com/upload/attachment/0081/9835/4c73daae-b12d-3c4f-972d-dbd2d1444ec3.png[/img]


面向对象的第一大特征:封装 Encapsulation

//1.是指隐藏对象的属性和实现的细节,仅对外提供公共访问的方式   
//函数是java中最小的封装体 

好处:  
    将变化隔离   
    便于使用, 
    提高重用性  
    提高安全性

封装原则
    将不需要对外提供的内部犯法隐藏起来
    把属性都隐藏,提供公共方法对其访问.

修饰符 关键字的使用

/**
private : 私有 ,修饰类中的成员变量  成员方法(函数) ,旨在本类中有效.

将 age 私有化后,类以外 即使建立了对象也不能直接访问.
但是 ren 应该有年龄,就需要在person类中提供对应访问age 的方式setAge()  getAge()

注意: 私有仅仅是封装的一种表现形式.

之所以提供对外访问的方式,是因为我可以在这里方法里面进行一些 逻辑判断等语句控制.
这样提高程序的健壮性. 


*/

class Person{
   private int age; //加入了 私有  外部就不能范围 

   void speark(){
      System.out.prinlnt("age="+age);
   }

// 一个属性只有  两个 操作方法 .一个 取值 一个赋值.
  public void setAge(int a){
     if(a>0 && a<130)
      age=a;
    else
      age=0;

  }

  public int  getAge(){
   return age;
  }

}


class PersonDemo{

  public static void main(String[] args){

      Person p=new Person();
      //p.age=-20;  //如果不私有 就会出现 安全问  出现了 -20的年龄 
      p.setAge(40); 
      p.speak();
  }


}

[img]http://dl.iteye.com/upload/attachment/0081/9901/8a07cfc1-5d9c-3f2f-bc05-64ab4e93ae4e.png[/img]


构造函数 和 构造代码快

//特点
1.函数和类名相同
2.不用定义返回值类型
3.不可以用return语句

//作用
给对象进行初始化

//注意
1.默认构造函数的特点
2.多个构造函数都是已重载的形式存在的.
3.构造函数的小细节: 当一个类中没有定义构造函数时,系统会默认你给该类加入一个空参数的构造函数 (如果自己定义了,系统就不会添加这个函数)

4.构造函数 也是函数的一种 ,所以具备 函数重载的特点

5.构造函数 如果为private  类就不能被外边初始化


//和一般方法的区别
1.写法上不同
2.在运行上不同 
   构造函数在对象一建立就运行  
   一般方法,是 对象调用才运行,是给对象添加的具备的功能.

3.一个对象建立,构造方法只运行一次.
  而一般方法.对象可以调用多次.

//什么时候定义构造函数呢

当一个事物一存在就具备一些特性或者行为,就将这些内容定义在构造函数中.


/**
构造函数: 对象一建立就会调用与之对应的构造函数.

构造函数的作用,可以用户给对象进行初始化 
*/
class person{
   private String name;
   private int age;

/**构造代码快     对象一建立就运行 ,优先于 构造函数执行.
和构造函数的区别
构造代码快是给所有兑现都统一初始化
构造函数是给对应的对象初始化
*/
{
  System.out.println("Person code run"):
  cry(); //不同对象的共性初始化内容  就不用在不同的构造函数中调用了

}
   /*
   Person(){
      System.out.println("A: name="+name+",age="+age);
     //cry();
   }*/ 

   Person(int a){
      age=a;
      System.out.println("B: name="+name+",age="+age);
      //cry();
   }

   Person(string n,int a){
      name=n;
      age=a;
      System.out.println("C: name="+name+",age="+age);
      //cry();
   }

  public void cry(){
    System.out.println("孩子哭了!");
  }
}

class PersonDemo{

   public static void main(String [] args){

      Person p=new Person();  //如果无参数的构造函数 被注释了, 就会报错找不到 初始化方法.
      Person p1=new Person(1);
      Person p2=new Person("alice",1);

   }


}

this 的用法

/**
this: 看上去,是用于区分局部变量和成员变量的同名情况

this: 就表示本类的对象.到底代表那一个呢?
this:  代表所在函数所属对象的引用

简单说: 哪个对象在调用this所在的函数,this就代表哪个对象.
*/

class Person{
 private String name;
 private int age;

Person(int age){
this.age=age;
}

/*
 Person(String name){
  name=name; 
 }
*/
 Person(String name){
  this.name=name; 
 }

public void speak(){
  System.out.println("name"+name+",age="+age);
}

/*
需求,给人定义一个用户比较年林是否相同的功能,也就是是否是同龄人
*/
public boolean compare(Person p){
   return this.age==p.age;  //使用 this 表示谁调用这个方法就表示那个对象. this 的地址值指向 那个对象 .
}


}


class PersonDemo{

 public static void main(String[] args){

     Person p=new Person("lisi");  
     p.speak(); // 如果没有使用this name=nulll,age=0;  

     Person p1=new Person(21);
     Person p2=new Perseon(25);
     p1.compare(p2);

  }
}

构造函数间的引用

/**
this 语句  :用于 构造函数间的互相调用.

this 只能放在 构造函数的第一行.应为初始化要先执行.
*/
class Person{
  private String name;
  private int age;

 Person(){
    // this("haha");  不能出现 否则就死循环了
  System.out.println("Person code run"): //3
 }

 Person(String name){
   this();  //2
   this.name=name; 
 }

 Person(String name,int age){

    //this.name=name;  
    this(name);   //this 语句  1
    this.age=age; 
 }


}