面向对象概述、类与对象、封装、构造函数、this关键字

一、面向对象

概念

        面向对象是相对面向过程而言，面向对象和面向过程都是一种思想。

        面向过程：

 强调的是功能行为。代表语言：C语言。

        面向对象：

                将功能封装进对象，强调具备了功能的对象。代表语言：Java、C++、C#。

特点

         是一种符合人们思考习惯的思想，可以将复杂的事情简单化，将程序员从执行者转换成了指挥者。

         完成需求时：

                1.先要去找具有所需功能的对象来用。

                2.如果该对象不存在，那么创建一个具有所需功能的对象。

                这样可以简化开发并提高复用。



面向对象的特征：
         封装(encapsulation)
 继承(inheritance)
 多态(polymorphism)

二、类与对象之间的关系

java中描述事物通过类的形式体现，类是具体事物的抽象，概念上的定义。对象即是该类事物实实在在存在的个体。

类的定义

         Java中用类class来描述事物。
         属性：对应类中的成员变量。
         行为：对应类中的成员函数。

         定义类其实在定义类中的成员(成员变量和成员函数)。

成员变量和局部变量的区别？

         成员变量：
 1.成员变量定义在类中，在整个类中都可以被访问。
                2.成员变量随着对象的建立而建立，随着对象的消失而消失，存在于对象所在的堆内存中。
 3.成员变量有默认初始化值。
         局部变量：
 1.局部变量只定义在局部范围内，如：函数内，语句内等，只在所属的区域有效。
 2.局部变量存在于栈内存中，作用的范围结束，变量空间会自动释放。
 3.局部变量没有默认初始化值。

匿名对象

         匿名对象是对象的简化形式。
         匿名对象两种使用情况：
                1.当对对象方法仅进行一次调用时；
                2.匿名对象可以作为实际参数进行传递。

示例：

class Car//定义一个car类
{
	 String color = "red";//定义两个成员变量color,num
	 int num = 4;

  public static void run()//定义一个方法
  {
	System.out.println("function run is running!" );
  }
}

class CarDemo
{
  public static void main(String[] args)
  {
	// 对对象方法仅进行一次调用时，就可以使用匿名对象
	 new Car().run();
	// 匿名对象可以作为实际参数进行传递
	 show(new Car());
  }
  public static void show(Car c)
  {
	 c. num = 3; 
	 c. color = "black" ;
	 System.out.println("function show is running!" );//打印
	 System.out.println(c.num + "..." + c. color);打印出c对象的num和color
  }
}

三、封装

封装：是指隐藏对象的属性和实现细节，仅对外提供公共访问方式。

好处：

        1.将变化隔离。

        2.便于使用。

        3.提高重用性。

        4.提高安全性。

封装原则：

        1.将不需要对外提供的内容都隐藏起来。

        2.把属性都隐藏，提供公共方法对其访问。如，getXXX，setXXX。

示例：

/*
人：
属性：年龄
行为：说话 
*/
class Person
{
  //private ：私有，是一个权限修饰符，用于修饰
  // 不希望别人直接访问赋值，需要通过私有化把属性进行隐藏 
  private int age ;
  // 通过提供 set 、 get 公共方法对其访问
  public void setAge( int a)//定义一个set方法可以修改Age
  {
	// 在 set 方法内可以对属性的赋值进行限制
	if (a > 0 && a < 130)
	{
		 age = a;
	 } 
	 else
	 System.out .println(" 错误的数据 " );//打印
  }	
  public int getAge()//定义一个getAge方法,可以获取age
  {
	return age ;
  }
  void speak()//定义一个speak方法，可以说出age
  {
	System.out .println("age = " + age);
  }
}

class PersonDemo
{
	public static void main(String[] args)
	{
		Person p = new Person();
		 // 通过其他方式访问
		 p.setAge(20);
		 p.speak();
		// 赋值不合法， set 方法就不允许成功赋值
		 p.setAge(-20);
	 }
}

 1.私有仅仅是封装的一种体现而已。
2.private关键字：是一个权限修饰符，用于修饰成员(成员变量和成员函数)，被私有化的成员只在本类中有
效。
3.常用场景之一：将成员变量私有化，对外提供对应的set、get方法对其进行访问，提高对数据访问的安全
性。

四、构造函数

特点：
        1.函数名与类名相同。
        2.不用定义返回值类型。
        3.没有具体的返回值。

P.S.
        在构造函数前面加上返回值就只是一般函数了。
        作用：给对象进行初始化。

示例：

class Person
{
	private String name ; 
	private int age ;
	// 定义一个 Person 类的构造函数
	// 构造函数，而且是空参数的
	Person()
	{
		System.out.println("person run");
	}
	public void speak()//定义一个speak方法
	{
		System.out.println(name + ":" + age);  
	}
}
class ConsDemo
{
  public static void main(String[] args)
  {
	// 构造函数：构建创造对象时调用的函数
	// 作用：可以给对象进行初始化
	 Person p = new Person();//创建一个Person对象
	p.speak();//调用speak方法
  }
}

1.一般函数和构造函数什么区别呢？
 构造函数：对象创建时，就会调用与之对应的构造函数，对对象进行初始化。
           一般函数：对象创建后，需要函数功能时才调用。
           构造函数：对象创建时，会调用并且只调用一次。
           一般函数：对象创建后，可以被调用多次。
2.创建对象都必须要通过构造函数初始化。
           一个类中如果没有定义过构造函数，那么该类中会有一个默认的空参数构造函数。
           如果在类中定义了指定的构造函数，那么类中的默认构造函数就没有了。
3.多个构造函数是以重载的形式存在的。

五、this关键字

this代表其所在函数所属对象的引用。换言之，this代本类对象的引用。
当成员变量和局部变量重名，可以用关键字this来区分，this就是所在函数所属对象的引用。
简单说，哪个对象调用了this所在的函数，this就代表哪个对象。一般方法调用默认加this。

什么时候使用this关键字呢？
         当在函数内需要用到调用该函数的对象时，就用this。

示例：

class Person
{
	private String name;//将两个成员变量name,age私有化
	private int age ;
	Person(String name)//定义一个构造函数
	{
		//通过this区分成员变量和局部变量
		this.name=name;
	}

	Person(String name,int age)定义另一个构造函数
	{
		//this也可以用于在构造函数中调用其他构造函数
	this(name);
	this.age = age;
	}
	public void speak()//定义speak方法
	{
		System.out.println(name + ":" + age);
	}
}

class ConsDemo2
{
	public static void main(String[] args)
	{
		Person p1 = new Person("旺财" );//创建一个Person对象
		p1.speak();//调用speak方法
		Person p2 = new Person("小强",10);//创建一个Person对象
		p2.speak();//调用speak方法
	}
}

通过this在构造函数中调用其他构造函数的时候，只能定义在构造函数的第一行，因为初始化动作要先执行，否则就会报错。