java基础要点（4)面向对象思想

面向对象概念：
面向对象是一种思想，相对面向过程而言更加简单，面向过程是强调的功能行为，而面向对象是将功能封装进对象，强调了具备功能对象，
从原来的执行者变成了指挥者

名词提炼法：人开门
人
{
 开门（门）
 {
  门.开（）；
 }
}

门
{
 开（）
 {操作门轴}
}

面向对象：三个特征：封装、继承、多态

开发过程：就是找对象使用，没有对象，就自己创建对象
设计过程：找对象，建立对象，使用对象，维护对象的关系

类和对象的关系：举例说明

现实生活中的对象：张三、李四
想要描述：提取对象中的共性内容，对具体的抽象

描述时：这些对象的共性有：姓名、年龄、性别等

映射到java中，描述的就是class定义的类
具体对象就是对应java在堆内存中用new建立的实体

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

 

成员变量和局部变量
1、作用范围：
 成员变量作用于整个类中
 局部变量作用于整个函数中
2、在内存中的位置：
 成员变量：在堆内存中，因为对象的存在，才在内存中存在
 局部变量：存在栈内存中
3、初始化
 成员变量有默认初始化值
 局部变量没有默认初始化值，必须手动初始化
 

//需求：描述汽车（颜色，轮胎数）
//分析：描述事物就是在描述事物的属性和行为
//属性对应的是类中的变量，行为对应的是类中的函数也就是方法
//其实定义类，就是在描述事物，就是在定义属性和行为，属性和行为共同成为类中的成员（成员变量和成员方法）
class Car
{
	String color="red";
	int num=4;
	void run()
	{
		System.out.println("color="+color+".....num="+num);
	}
}
class CarDemo
{
	public static void main(String[] args)
	{
		Car c=new Car();
		c.color="blue";
		c.num=5;
		c.run();
		new Car().run();
		show(new Car());
		/*
			匿名对象使用方式之一：当对对象的方法只调用一次时候，可以用匿名对象来完成，这样写比较简化
									如果对一个对象进行多个成员调用，必须给这个对象起个名字
			匿名对象使用方式之二：可以将匿名对象作为实际参数进行传递。
			
		*/
		
	}
	public static void show(Car c)
		{
			c.num=3;
			c.color="yellow";
			c.run();
		}
}

 

private:私有权限修饰符：用于修饰类中的私有只在被类中有效。

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

class Person
{
	private int age;
	
	//将成员变量age私有化以后，类以外即使建立了对象也不能直接访问，
	//但是人应该有年龄，就需要在Person类中提供对应访问age的方式。
	//之所以对外提供访问方式，就因为可以在访问方式中加入逻辑判断等语句
	//对访问的数据进行操作，提高代码的健壮性
	private String name;

	public void setAge(int age)
	{
		if (age<130 &&age>0)
		{
			this.age=age;

this:看上去，是用于区分局部变量和成员变量同名情况。

this：就代表本类的对象，它代表他所在函数所属对象的引用
  简单地说：哪个对象在调用this所在的函数，this就代表哪个对象

this的应用：当定义类中功能时，该函数内部要用到调用该函数的对象时，
   这时就用this来表示这个对象
   但凡本类功能内部使用了本类对象，都用this表示

			speak();
		}
		else
			System.out.println("非法年龄");
		
	}
	public int getAge()
	{
		return age;

	}
	public void setName(String name)
	{
		this.name=name;
	}
	public String getName()
	{
		return this.name;
	}
	public void speak()
	{
		System.out.println("age="+age+"name="+name);
	}
	//需求：给人定义一个用于比较年龄是否相同的功能，也就是是否是同龄人
	public boolean compare(Person p)
	{
		return this.age==p.age;
	}

	
	Person()
	{
		speak();
	}
	Person(String name)
	{
		this();

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

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

		this.name=name;
		speak();
	}
	
	Person(String name,int age)
	{
		this.name=name;
		this.age=age;
	}
}
class PersonDemo
{
	public static void main(String[] args)
	{
		Person p=new Person();
		p.setAge(23);
		
		Person p1=new Person();
		//p1.setAge(-49);
		p1.setAge(33);
		
		boolean b=p1.compare(p);
		System.out.println(b);

		Person p3=new Person("zhangsan");

	}
}

对象一建立就会调用与之对应的构造函数。

构造函数的作用：可以用于给对象进行初始化

构造函数的小细节：
当一个类中没有定义构造函数时，那么系统会默认给该类加入一个空参数的构造函数。

当在类中自定义了构造函数后，默认的构造函数就没有了

构造函数和一般函数在写法上有些不同；在运行上也有不同

1、构造函数是在对象已建立就运行，给对象初始化

2、而一般方法是对象调用才执行，是给对象添加对象具备的功能。

一个对象的建立，构造函数只运行一次；而一般方法可以被该对象调用多次

什么时候定义构造函数呢？
当分析事物时，该事物存在具备一些特性或者行为，那么将这些内容定义在构造函数中。

class Person1
{
	private String name;
	private int age;

 构造代码块
 作用：给对象进行初始化
 对象一建立就运行，而且优先于构造函数执行

 和构造函数的区别：
 构造代码块是给所有对象进行统一初始化，
 而构造函数是给对应的对象初始化

 构造代码块中定义的是不同对象共性的初始化内容
 
 

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

	}
	Person1(String name)
	{
		this.name=name;
		System.out.println("B:name="+name+",,,,age="+age);
	}
	Person1(String name,int age)
	{
		this.name=name;
		this.age=age;
		System.out.println("C:name="+name+",,,,age="+age);
	}

	public void setName(String name)
	{
		this.name=name;
	}
	public String getName()
	{
		return name;
	}
	public void cry()
	{
		System.out.println("cry.......");
	}
}
class PersonDemo2
{
	public static void main(String[] args)
	{
		Person1 p=new Person1();
		p.setName("zhangsan");
		System.out.println("......"+p.getName()+"......");
		Person1 p1=new Person1("lisi");
		p1.setName("zhaoliu");
		System.out.println("......"+p1.getName()+"......");
		Person1 p2=new Person1("wangwu",34);
		
	}
}