JAVA面向对象的三大特性

------- java学习型技术博客、期待与您交流 ----------

三大特性

JAVA特性之---------------封装

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

     封装实际上是使用方法将类的数据隐藏起来，控制用户对类的修改和访问数据的程度。

好处：

将变化隔离；

便于使用；

提高重用性；

安全性。

封装原则：将不需要对外提供的内容都隐藏起来，把属性都隐藏，提供公共方法对其访问。

（java书上都说是为了防止对类内部的无意义更改，造成代码混乱，个人理解是：个人理解，要做高抽象开发，没必要了解底层的详细实现细节，这样才能把心思放高，既然没必要了解，那就隐藏起来吧，要充分相信程序员！）

说到封装就不得不提一个权限修饰符：private

Private:私有权限修饰符，用于修饰类中的成员（成员变量，成员函数）。私有只在本类中 有效。

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

下面的例子可以简单的说明封装的好处和表现形式

Class Person
{
　　int age;//未对年龄属相进行私有化，外界可以直接访问并操作它。
　　void speak()
　　{
　　System.out.println(“age=”+age);
　　}
}
class PersonDemo
{
　　public static void main(String[] args)
　　{
　　Person p = new Person();
　　p.age = -20;//对年龄进行赋值的时候可以赋给一个负数，显然不符合常理也安全性
　　p.speak();
　　}
}

 

接着用封装的思想对代码进行优化：

class Person
{
	//将年龄属相设置为私有，外界不能直接访问
	private int age;

	//对外提供设置年龄的方法，在此方法中加入逻辑判断等语句
	//对访问的数据进行操作，提高代码健壮性
	public void setAge(int a)
	{
		//对年龄进行判断
		if(a>0 && a<130)
		{
			age = a;
			speak();
		}
		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);//这里输入为负数的年龄程序就会给出相应的提示
	}
}

运行结果如下

总结：

1.封装的定义：用书面的话说就是隐藏细节实现，按我的理解就是把一系列的数据放到一个类中，储存的数据只能在这个类中使用，以及在它的测试类中可以调用，其他的类是没有调用权限的。

2.封装中所涉及的最重要的关键字有private，public；

private是将属性私有化，也就是将其封装在这个类中并且通过公有的方法来访问它（如：public）。

3.封装的实现是通过get和set两个方法来实现的set方法是用来给私有后的属性进行赋值的而get方法是用来取值的，通过类的调用将其输出。

---------------------------------------------------------------------------------------------------------------------------------------------------------

JAVA特性之---------------继承

概念：Java继承是使用已存在的类的定义作为基础建立新类的技术，新类的定义可以增加新  的数据或新的功能，也可以用父类的功能，但不能选择性地继承父类。这种技术使  得复用以前的代码非常容易，能够大大缩短开发周期，降低开发费用。关键字：extends

好处：

     1，提高了代码的复用性

     2，让类与类之间产生了关系，为多态提供了前提。

注意：继承虽然能够简化代码，但也不能因为这个随便继承，因为继承的前提是两个类之间                          存在所属关系。例如class B继承自Class A，那么他们的所属关系便是：B is a A 。   也就是说，先有父类，再有子类。如果想要简化代码，可以通过向上抽取共性的方法，   将共性特征单独定义在一个类里面，然后让其它类继承自共性类，这样既可以简化代   码，也能够避免错误的继承。

例如：有一个类A，它有两个方法: func_1()和func_2()

有个类B它也有一个func_1()方法和一个func_3()方法。

那么不能因为他们又一个共 性方法func_1就让Class B extends A，因为Class  B  中并不具备func_2() 。

 正确的做法是，抽取他们的共性方法func_1(),并继承自它func_1()所属的类

注意：java只支持单继承，不支持多继承。一个孩子只能有一个父亲！

      因为多继承容易带来安全隐患，当多个类中定义了相同的功能，当功能类容不同  时，      子类对象不确定运行哪一个。

       (但是java保留了这种机制，并用另一种体现形式来完成，多实现)

       Java支持多层继承，也就是一个继承体系。当使用体系时候，记住一句话：“查阅父 类描述，创建子类对象”

子类中函数的特点：

1，当子类出现和父类一摸一样的函数时候，子类对象调用该函数，会运行子类函数的内容，这是函数的一个特性：重写（覆盖）

2，在对子类对象进行初始化时，父类的构造函数也会运行，那是因为子类的构造函数默认第一行有一句隐式的语句super();

super():会访问父类中空参数的构造函数，而且子类所有的构造函数默认第一行都是super();

原因：

因为对象可以直接访问父类中的数据，所以子类对象在建立时，要先查看下父类中是如何对这些数据进行初始化的，所以要先访问以下父类中的构造函数。

如果子类构造函数中用this来指定调用子类自己的构造函数，那么被调用的构造函数也一样会访问父类中的构造函数（至少一次）。

代码示例：

class Fu 
{
	Fu()
	{
		System.out.println("fu run");
	}
	Fu(int x)
	{
		System.out.println("fu....."+x);
	}
}
class Zi extends Fu
{
	Zi()
	{
　　//这里有一句默认的super();
		System.out.println("zi run");
	}
	Zi(int x)
	{
　　//这里有一句默认的super();
		super(3);
		System.out.println("zi..."+x);
	}
}
class ExtendsDemo1
{
	public static void main(String[] args)
	{
		Zi zi = new Zi();
		Zi zi1 = new Zi(5);
	}
}

 

 ExtendsDemo1运行结果：  

class Fu 
{
	Fu()
	{
		System.out.println("fu run");
	}
	Fu(int x)
	{
		System.out.println("fu....."+x);
	}
}
class Zi extends Fu
{
	Zi()
	{
　　//这里有一句默认的super();
		System.out.println("zi run");
	}
	Zi(int x)
	{
　　//这里没有默认的super();
		this();//调用本类空参数的构造方法
//本类空参数的构造方法又先调用了父类空参数的构造方法.
		System.out.println("zi..."+x);
	}
}
class ExtendsDemo2
{
	public static void main(String[] args)
	{
		Zi zi = new Zi();
		Zi zi1 = new Zi(5);
	}
}

ExtendsDemo2运行结果

 ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------

JAVA特性之---------------多态

多态：可以理解为事物的的多种表现形式，或者说某一事物有不同的具体体现。

（比如：人分为男人和女人，动物包括猫，狗，猪等等）

多态的体现：

    父类引用指向自己的子类对象。

    父类的引用也可以接受自己的子类对象。

多态的好好处:

   多态的出现大大的提高了程序的扩展性。（在进行程序更新或者升级时，比如说需要添加新的对象或者功能时，不用大动代码）

多态的局限性:

   只能使用父类的引用访问父类中的成员。（因为那时候可能子类都还没存在，即前期不能使用后期产生的功能）

多态的前提:

   必须是类与类之间有关系，要么是继承，要么是实现。

 通常还有一个前提，就是覆盖（前期预先调用功能，后期定义子类去覆盖并实现功能，并将子类作为参数传递进来）

代码示例：定义一个Animal类，具有一个抽象的eat()方法

定义Cat类继承自Animal类，覆盖eat方法，并有特有的catchMouse()方法

定义Dog类继承自Animal类，覆盖eat方法，并有特有的kanJia()方法

abstract class Animal//定义一个抽象类Animal
{
	public abstract void eat();//抽象方法eat();
}
class Cat extends Animal//定义一个Cat类继承自Animal类
{
	public void eat()//覆盖父类的eat();方法
	{
		System.out.println("吃鱼");
	}
	public void catchMouse()//子类特有的方法
	{
		System.out.println("抓老鼠");
	}
}
class Dog extends Animal
{
	public void eat()//覆盖父类的eat();方法
	{
		System.out.println("吃骨头");
	}
	public void kanJia()//子类特有的方法
	{
		System.out.println("看家");
	}
}
class  DuoTaiDemo
{
	public static void main(String[] args) 
	{
		function(new Cat());
		//下面这句代码有一个类型提升的动作（向上转型，将Dog提升为Animal类型）
		Animal d = new Dog();//父类的引用指向子类对象
		//调用Animal类中已有的方法eat();
		d.eat();
		/*如果想要调用dog的特有方法，需要强制将父类的引用，转成子类类型*/
		Dog dd = (Dog)d;
		dd.kanJia();

		//千万不要将父类对象转换成子类类型（前提都是父类引用指向子类对象，变化的只是子类对象）
		//Animal a = new Animal();   
		//Cat c = (Cat)a;			 			
	}

	public static void function(Animal a)//这就不用分别定义function传入具体的动物对象了
	{
		a.eat();
		//a.kanJia(); 编译不能通过，会提示找不到符号，因为Animal中没有这个方法
	}
}

多态中成员函数（非静态）的特点：

在编译时期，参阅引用型变量的类中是否有调用的的方法

在运行时期，参阅对象所属的类中是否有调用的方法

（编译看左边，运行看右边）

静态成员函数无论编译或者运行都看左边

多态中成员变量的特点:

 无论编译和运行都参阅引用型变量的类，（编译运行都看左边）

class Fu
{
	int num =5;
	void method1()
	{
		System.out.println("Fu method1");
	}
	void method2()
	{
		System.out.println("Fu method2");
	}
	static void method4()//父类静态成员函数。
	{
		System.out.println("Fu method4");
	}

}
class Zi extends Fu
{
	int num = 8;
	void method1()
	{
		System.out.println("Zi method1");
	}
	void method3()
	{
		System.out.println("Zi method3");
	}
	static void method4()//子类的静态成员函数
	{
		System.out.println("Zi method4");
	}
}
class  DuoTaiDemo2
{
	public static void main(String[] args) 
	{
		Fu f = new Zi();//成员变量，无论编译和运行都参阅引用型变量的类
		System.out.println(f.num);
		f.method1();//参阅f对象自身所属的类，Zi中的方法
		f.method2();//因为Zi中没有method2()方法，参阅引用型变量中的方法。
		//f.method3();//编译会报错，"找不到到符号"因为Fu类中没有method3这个方法
		f.method4();//静态成员函数，无论编译还是运行都看左边。
		Zi z = new Zi();
		System.out.println(z.num);
	}
}

编译时期对然Zi中有method3方法，但是因为Fu中没有这个方法，所以会报错

运行时期会先参阅Zi类中自己的方法，所以会运行子类自由的method1方法，当Zi类中没有method2时才会调用父类中的method2方法。

运行结果为：

------- java学习型技术博客、期待与您交流 ----------