06.面向对象(3)--面向对象3大特性：封装、继承和多态

6、面向对象3大特性：封装、继承和多态

 

6.1 封装性：

每个对象都包含了他能进行操作所需要的所有信息，因此对象不必依靠其他的对象来完成自己的操作，这样的特性叫封装。

例如：

   class Person{
        private int age;
	    public void setAge(int i){
		    if(i<0 || i>130)
		    	return;
		    age = i; 
	    }
	    public int getAge(){ 
		return age;
		}
	}
	public class TestPerson{
	    public static void main(String args[]){
            Person p1 = new Person();
		    p1.setAge(3);
		    p1.setAge(-6);
		    System.out.println(p1.getAge());
        }
    }

 

 

 

实现封装可以达到如下目的：

1)隐藏类的实现细节；

2)让使用者只能通过事先定制好的方法来访问数据，可以方便地加入控制逻辑，限制对属性的不合理操作；

3)便于修改，增强代码的可维护性；

4)可进行数据检查；

 

 

 

6.2 继承性

继承代表了一种“is-a”的关系，个人觉的继承的最大好处是少些好多的代码及多态功能

例如：

class Person{
      public String name;
      public int age;
	  public Person(String name,int age){
		this.name=name;
		this.age=age;
	  }
	  public Person() { //如果你不写这个构造函数，看看对类Student有什么影响。
	  
	  }
      public void getInfo(){
       	System.out.println(name);    
      	System.out.println(age);    
      }
	}
	class Student extends Person{
      public void study(){
      	    System.out.println("Studding");
      }
      
      public static void main(String[] args){
      	Person p=new Person();
      	p.name="person";
      	p.age=30;
      	p.getInfo();
      	
      	Student s=new Student();
        s.name="student";
        s.age=16;
        s.getInfo();
        s.study();
      }
}

 

 

 

在类的继承中，有这样的一些细节问题：

1).通过继承可以简化类的定义，我们已经在上面的例子中了解到了。

2).Java只支持单继承，不允许多重继承。在Java中，一个子类只能有一个父类，不允许一个类直接继承多个类，但一个类可以被多个类继承，如类X不可能既继承类Y又继承类Z。

3).可以有多层继承，即一个类可以继承某一个类的子类，如类B继承了类A，类C又可以继承类B，那么类C也间接继承了类A。这种应用如下所示：

	class A {}
	class B extends A{}
	class C extends B{}

 

 

 

4).子类继承父类所有的成员变量和成员方法，但不继承父类的构造方法。在子类的构造方法中可使用语句super(参数列表) 调用父类的构造方法。如：我们为Student类增加一个构造方法，在这个构造方法中我们用super明确指定调用父类的某个构造方法。

	class Student extends Person{
		public Student(String name,int age,String school)
		{
			super(name,age);
			this.school=school;
		}
	}

 

 

 

5).如果子类的构造方法中没有显式地调用父类构造方法，也没有使用this关键字调用重载的其它构造方法，则在产生子类的实例对象时，系统默认调用父类无参数的构造方法。也就是，在下面的类B中定义的构造方法中，写不写super()语句效果是一样的。

	Public class B extends A{
		public B(){
			super();//有没有这一句，效果都是一样的。
		}
	}

 

 

6.3 多态性

定义：是允许将父对象设置成为和一个和多个它的子对象相等的技术，比如Parent=Child 赋值之后，父对象就可以根据当前赋值给它的子对象的特性以不同的方式运作。也就是说，父亲的行为像儿子，而不是儿子的行为像父亲。 

1).子类转换成父类

例如：

	class A{
		public void func1()
		{
			System.out.println("A func1 is calling");
		}
		public void func2()
		{
			func1();
		}
	}
	class B extends A{
		public void func1()
		{
			System.out.println("B func1 is calling");
		}
	    public void func3()
	    {
			System.out.println("B func3 is calling");
		}
	}
	class C{
		public static void main(String [] args)
		{
			B b=new B();
			A a = b;
			callA(a);
			callA(new B());
		}
		public static void callA(A a)
		{
			a.func1();
			a.func2();
		}
	}

 

 

2).父类转换成子类

例如：

public static void CallA(A a){
		B b=（B）a;
		b.func1();
		b.func2();
		b.func3();
	}

 3).instanceof 操作符

可以用instanceof 判断是否一个类实现了某个接口，也可以用它来判断一个实例对象是否属于一个类。还是用上面的代码来举例：

 

public static void CallA(A a){
		if(a instanceof B){
			B b=(B)a;
			b.func1();
			b.func2();
			b.func3();
		}else{
			a.func1();
			a.func2();
		}
	}

 

4).在前面讲到的子类自动转换成父类的例子中，我们的调用程序是这么写的：

 

class C{
		public static void main(String [] args){
			B b=new B();
			A a = b;
			callA(a);
			callA(new B());
		}
		public static void callA(A a){
			a.func1();
			a.func2();
		}
	}

 程序运行结果是：

B func1 is calling

B func1 is calling

B func1 is calling

B func1 is calling