Java 面向对象基础

由于对此概念产生了模糊，所以再来总结学习一下，不对之处，请指正。

说起面向对象，首先要说明一下Java类，其本质是用来描述事物类型的。关于Java方法的创建和重载和类的定义、声明，由以下演示：

class  类名{//类名一般大写
	属性;
	方法：
	访问修饰符 返回值类型 方法名(){
		方法主体	
	}
}

其中，注意Java方法的返回值类型，如果没有特殊要求返回值类型，可以定义为void，这样就不需要在此方法结束的时候return一个该返回类型的值，除void以外的int、String、float等均需要返回对应类型的数值。

关于重载Java方法，即方法名相同，只是参数类型或者个数不同而已，如下。

public void Person(int age) {
}
public void Person(String name) {
}

从上边儿的示例可以看出，仅仅改变了Person传入参数的类型，即实现了Java方法的重载。

接下来看类与对象的关系：

1.类：就是对现实生活中事物的描述，主观抽象，是对象的模板，可以实例化对象。//映射到java中，描述就是class定义的类。

习惯上，类的定义中除了上文阐述的，还有一个默认的构造函数（或者称为构造器）。构造函数的作用主要是给对象进行初始化，当一个构造函数建立时，就会调用与之相对应的构造函数。而如果类中没有定义构造函数，则系统会默认给该类加入一个空参数的构造函数。构造函数的创建方法和Java方法的创建相似，因为其本质也属于一个Java方法。但在运行时有很大的区别，构造函数在对象建立时就会立即运行，给对象初始化，而一般Java方法则在对象调用该方法时才会被运行，同时，构造函数只运行一次。

class Person
{
	//Person(){}  空参数构造函数。
	private String name;
	private int age;
	public void main( String[] args)
	{
		System.out.println("person code run");
	}
	//函数的重载
	Person()
	{
		System.out.println("A:name="+name+"..age="+age);
	}
}

上述代码中，注释掉的Person(){}，即为空参数构造函数，因为下面将该函数进行了重载，空参数Person()就不能再出现。

2.对象：就是这类事物，实实在在存在的个体，类的个体。//new 映射到堆内存中的一个实体。

先看一个简单的例子：

class  Demo
{
	public static void main(String[] args) 
	{
		Person per;//声明
		per = new Person();//实例化
		Person per = new Person();//声明并实例化
	}
}
class Person{
	
}

其中，包含了一个类的声明、实例化方法。这里需要对实例化的过程说明一下，就拿

Person per = new Person("zhangsan",25);

这句代码来看，它具体的执行了哪些操作？

首先，new用到了Person.class，所以先找到该文件并加载到内存中。如果该类中有相对应的静态方法，则执行该方法对Person.class进行初始化。然后在堆内存中开辟空间，分配内存地址，其中的Person per是在栈内存中指向堆内存的，使用new开辟一个堆内存空间来对内存中建立的对象per进行默认初始化。对per属性进行初始化，比如name、age等，然后对对象进行对应构造函数的初始化，最后将内存地址赋予变量per。

3.面向对象的特征：封装、继承、多态

1>封装，顾名思义，就是将一个事物自我封装起来，外界看不到内部，只有自己可以看到自己内部，比如一个快递，用箱子封装起来一样，你不拆开箱子，你是看不到内部有什么东西的，而箱子内部的东西知道内部有什么(What the hell?我用了拟人的手法[手动滑稽])。而Java中的封装也一样，是为了不让外部访问到内部，只是提供一个接口，可以让外部来进行调用，具体内部的方法不会让你去修改，典型的封装就是jar包。

2>继承，也很简单，就是将父类的东西传承下来，在定义和实现一个子类的时候，不用再去重复的书写已有的方法，继承和封装的区别在于，前者可以对父类的一些方法进行复写和修改，而后者只能调用不能修改。继承提高了代码的扩展性和重复使用性。

3>多态，这个目前本人没有用到多，所以也不好说怎么使用，希望在以后的使用中再来完善。

4.说完了上述的一些基本内容，索性再来巩固一下基础知识，接下来，简单总结一下变量和访问修饰符等一些基础知识。

1>变量分为局部变量和全局变量，从名称就可以看出，二者的作用范围不同，如下

class  Demo
{
	String name;
	int age;
	public static void main(String[] args) 
	{
		float num;
		char ch;
	}
}

其中，name和age均作为全局变量存在，作用于整个类，而num和ch仅仅在main方法中可以调用。

2>几种访问权限
public：此种修饰，表示任何地方均可以访问。

protected：在此类内部，或者同一个包中，子类中均可以访问到，是介于public和private两者之间的一种访问修饰符。

private：仅限当前类内部访问。

public class TestDemo{
	public void main(String[] args){
		sop(t.getNum());
	}
	
	public void sop(Object object){
		System.out.println(object);
	}
}
class Num{
	public int a = 1;
	protected  b = 2;
	private int c = 3;
	public int getNum(){
		return c；
	}
}

可以看出，编译失败，因为c定义为private，仅限于内部类访问，所以不能被外部的class访问到，但是getNum()方法因为是public定义的，所以TestDemo可以访问到。

3>其他的一些修饰符

static：使用static修饰的方法属于类的方法，在加载类以后就可以自己调用，不需要创建任何类的实例对象，使用方法：类名.方法名。

如：int abc = Num.getNum();

final：final修饰的类不能再被继承，其修饰的方法也不能被覆盖，而其修饰的变量在初始化后就不允许再修改了。

this：这个有必要重点说一下，乍一看，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="+this.name+"..age="+this.age);
		show();//省略this.
	}
	public void show()
	{
		System.out.println(this.name);
	}

	public boolean compare(Person p)
	{
		return this.age==p.age;
	
	}
}
class PersonTest 
{
	public static void main(String[] args) 
	{
		Person p1=new Person("张三",20);
		Person p2=new Person("李四",25);
		boolean b=p1.compare(p2);
		System.out.println(b);
		//Person p = new Person("李四");
		//p.speak();
	}
}