面向对象

面向对象（类与对象的关系）
一.面向对象的三个特征：封装，继承，多态
以后开发其实就是找对象使用，没有对象就创建一个对象。找对象，建立对象，使用对象，维护对象的关系。
类与对象的关系
类就是对现实生活中事物的描述
对象就是这类事物实实在在存在的个体
映射到java中，描述就是class定义的类，具体对象就是对应java在堆内存中建立的实体。

class Car
{
	String color="红色";//描述颜色
	int num = 4;//描述轮胎数

	void run()//运行行为
	{
		System.out.println(color+"..."+num)
	}
}

class  
{
	public static void main(String[] args) 
	{
		//生产汽车,在java中通过new操作来完成
		//其实就是在堆内存内产生一个实体.
		Car c = new Car();//c就是一个类类型变量。
		                   //记住：类类型变量指向对象。
			
		//需求：将已有车的颜色改为蓝色，指挥对象做事情，
			 // 在java中指挥方式是：对象.对象成员。
		c.color="blue";
		c.run();

	}
}


二.面向对象（成员变量和局部变量）
成员变量与局部变量的区别
作用范围不同
成员变量作用于整个类中
局部变量作用于函数中，或者语句中
在内存中的位置不同
成员变量存在于堆内存中，因为对象的存在才在内存中存在
局部变量存在于栈内存中。

三.匿名对象是对象的简化方式
Car c=new Car();
c.num=5;
前两句可以简化写成：new Car( ).num=5;（匿名对象）
new Car( ).color="blue";（匿名对象）
匿名对象的使用方式
(1)当对对象的方法只调用一次时，可以用匿名对象来完成，这样写比较简化（匿名对象调用属性没有任何意义），如果对一个对象进行多个成员的调用，必须给者个对象起个名字。

(2)可以将匿名对象作为实际参数进行传递

需求：描述汽车（颜色，轮胎数等）描述事物就是在描述事物的属性和行为。属性对应类中变量，行为对应类中函数。其实定义类就是在描述事物，就是在定义属性和行为。属性和行为共同成为类中的成员（成员变量和成员函数)
class Car
{
	String color="红色";//描述颜色  int num = 4;//描述轮胎数 void run()//运行行为
	{
		System.out.println(color+"..."+num);
	}
}
class  CarDemo
{
	public static void main(String[] args) 
	{
		Car  q = new Car();show(q);
		//show(new Car());
    }
	public static void show(Car c)
	{
		c.num = 3;c.color="black";c.run();
	}
}


四.面向对象（封装概述）
封装定义
     封装是指隐藏对象的属性和实现细节，仅对外提供公共方式。
封装的好处
将变化隔离
（2） 便于使用
（3）提高重用性
（4）提高安全性
封装的原则
将不需要对外提供的内容都隐藏起来。
把属性都隐藏，提供公共方法对其访问。

private:私有，权限修饰符。
        用于修饰类中的成员（成员变量和成员函数）将age私有化后，
        即使建立了对象也不能直接访问。但是人应该有年龄，
        就需要在person类中提供对应访问age的方式。

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

之所以对外提供访问方式，就因为可以在访问方式中
加入逻辑判断等语句，对访问方式进行操作，
提高代码的健壮性。


class Person
{
	private int age;
	public void setAge(int a)
	{
		if(a>0 && a<120)
		  age = a;
		else
			System.out.println("非法年龄");
	}
	public int getAge()
	{
		return age;
	}
	void speak()
	{
		System.out.println("age="+age);
	}
}
class PersonDemo
{
	public static void main(String[] args)
	{
		Person p = new Person();
		p.setAge(-20);
		p.speak();
	}
}

五.面向对象（构造函数）
构造函数的特点
函数名与类名相同
不用定义返回值类型
不可以写return语句
   对象一建立就会调用与之对应的构造函数
2.构造函数的作用:给对象进行初始化
3构造函数的小细节
当一个类中没有定义构造函数时，那么系统会默认给该类加入一个空参数的构造函数。Person（）{} ：空参数构造函数
当在类中定义了构造函数后，默认的构造函数就没有了。
4构造函数和一般函数的不同
写法不同
运行上也不同
构造函数是在对象一建立就运行，给对象初始化，一般函数是在对象调用才执行。一个对象建立，构造函数只运行一次，而一般函数可以被对象调用多次。
什么时候定义构造函数呢？
当分析事物时，该事物存在具备一些特征或者行为，那么将这些内容定义在构造函数中。

class Person
{
	  private String name;
      private int age;
      Person()
	     {
	        System.out.println("A: name="+name+",,"+"age="+age);
			  cry();
	     }
 	  Person(String n)
         {
		     name=n;
	        System.out.println("B: name="+name+",,"+"age="+age);
			  cry();
	     }
	  Person(String n ,int m)
	     {
	       name=n;
	       age=m;
	       System.out.println("C: name="+name+",,"+"age="+age);
		    cry();
	     }
	  public void cry()
	     {
           System.out.println("cry......................");
	     }
}


class PersonDemo
{
   public static void main(String[] args)
	{
     Person p1= new Person()
     p1.cry;
     p1.cry;
     Person p2= new Person("zhangsan");
     Person p3= new Person("lisi",25);
    }
}

六面向对象（构造代码块）
构造代码块的作用
给对象进行初始化，对象一建立就运行，而且优先于构造函数执行。

构造代码块和构造函数的区别
构造代码块是给所有对象统一初始化，而构造函数是给对应的对象初始化，构造代码块中定义的是不同对象共性的初始化内容。

class Person
{
	  private String name;
      private int age;
	     {
			 System.out.println("cry......................");
	     }
      Person()
	     {System.out.println("A: name="+name+",,"+"age="+age); }
 	  Person(String n)
         {   name=n;
	        System.out.println("B: name="+name+",,"+"age="+age);
		  }
	  Person(String n ,int m)
	     {  name=n;    age=m;
	       System.out.println("C: name="+name+",,"+"age="+age);
		  }
}
class PersonDemo
{
   public static void main(String[] args)
	{
     Person p1= new Person();
     Person p2= new Person("zhangsan");
     Person p3= new Person("lisi",25);
    }
}

七.面向对象（this关键字）
this看上去是用于区分局部变量和成员变量同名情况
this就代表本类的对象，到底代表哪一个呢？this代表它所在函数所属对象的引用。简单说，哪个对象在调用this所在函数，this就代表哪个对象。

class Person
{
	private String name;
	private int age;
	Person(String name)
	{
		this.name = name;
	}
	Person(String name, int age)
	{
		this.name = name;
		this.age = age;
		
	}
	public void speak()
	{
		System.out.println("name="+name+"...age="+age);
	}
}

class PersonDemo
{
	public static void main(String[] args)
	{
		Person p = new Person("lisi");
		p.speak();
	}

}

八.面向对象(this关键字在构造函数间调用)

this语句:用于构造函数之间进行相互调用

this语句只能定义在构造函数的第一行,因为初始化要先执行


class Person
{
	private String name;

	private int age;

	Person(String name)
	{
		this.name = name;
	}
	Person(String name, int age)
	{
		this(name);//这就是this语句,相当于this.name=name;
		this.age= age;
	}
}

class PersonDemo
{
	public static void main(String[] args)
	{
		Person p = new Person("lisi",24);
	}
}