java、面向对象的三大特征封装、继承、多态

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

一、封装

       1、什么叫封装？

              (1) 封装就是包装。

              (2)隐藏内部实现细节，隔离外界对内的直接操作。

              (3)仅对外提供公共访问方式。

              理解：对外界隐藏属性，开方部分方法。

       2、封装的好处？

             (1)将变化隔离。

             (2)便于使用。

             (3)提高重用性。

实例:

public class Test {
   
 public static void main(String[] args){
	display();//调用打印"hello,word"的方法即可
}	
   public static void display() { //将打印"hello,word"的功能封装在一个方法中
     System.out.println("hello,word");
    }
}

 

二、继承的由来
　　如果多个类中存在相同的属性和方法，那么可以把相同的部分抽取出来，放到一个单独的类中，然后让原来这些类去继承这个单独的类。这样原来的类就无需再去定义这些相同的属性和方法了。

     1、继承的特点和注意事项
           (1)继承的体系结构：就是对要描述的事物进行不断的向上抽取，就出现了体系结构。
           (2)继承的好处：
               A：继承的出现，提高了代码的复用性。
               B：继承的出现，让类与类之间产生了关系，extends来表示，
              这个关系的出现，为后面我们面向对象的第三个特点多态打下了基础。
           (3)特点
               A：java只支持单继承(其实确切的说是java对多继承进行了优化，避免了安全问题)。
               B：java支持多重(层)继承。
           (4)注意：
               A：子类可以直接访问父类中的非私有的属性和行为。
               B：不要仅为了获取其他类中部分功能而去继承。
               C：类与类之间要有所属( " is a " )关系，xx1是xx2的一种。
          **如何判断A和B是否有继承关系？
          **A如果继承B，那么就可以说A是B的一种。

实例:

class Father
		{
			int num1 = 5;
		}

	    class Son extends Father
		{
			int num1 = 20;
			int num2 = 10;
				public void show()
			{
				int num1 = 30;
				System.out.println("num1:"+num1);
				System.out.println("num2:"+num2);
				//局部范围内有的变量，如果我想使用成员变量，怎么办？this
				System.out.println("this num1:"+this.num1);
				//就想子类中访问父类中和子类同名的变量super
				System.out.println("father num1:"+super.num1);
			}
		}

总结：使用子类中的成员变量时，首先看局部有没有和成员变量同名的，如果有就是用局部的。
        其实，在子类的成员变量里面找，如果有，直接输出。
        最后，在父类中找同名的变量，如果有，就输出父类的值。否则报错。

        this和super的区分：
        **this代表本类对象的引用
   super代表父类的内存空间的标识。
        **this可以用于区分局部变量和成员变量同名的情况。
   super可以用于区分子类和父类成员变量同名的情况。
        **一般，子类中不会出现和父类同名的成员变量。

     2.重写的特性

实例：

class Father
		{
			public void show()
			{
				System.out.println("father show");
			}
		}

		class Son extends Father  //子类继承了父类
		{
			public void show()  //子类重写了父类的show方法
			{
				System.out.println("son show");
			}

			public void show1()
			{
				System.out.println("son show1");
			}
		}

总结：在使用子类的成员方法时：首先在子类中找，其次在父类中找。否则，报错。
        super可以在子类中使用父类的成员方法。
   
   子类中存在和父类成员方法同名的这种现象，叫做重写，复写，覆盖。
   重写(override)和重载(overload)的区别：
   重载的特点：
    **在同一类中。
    **方法名相同，参数列表不同。
   重写的特点：
    **要有继承关系。在子父类中
    **方法的声明相同。(方法名和参数列表都相同)
     ***覆盖时，子类方法权限一定要大于等于父类方法权限
     ***静态只能覆盖静态。

注意:在继承中，父类的static.private修饰的成员变量和方法是无法继承的，继承只是继承了父类的所有public的东西。

 

 

三、多态调用的概念

          重载：编译器确定要调用的是哪一个方法。同一条调用语句，但调用的哪个重载版本的方法是多态的！

         重写：JVM确定调用的是哪一个方法。同一个类型的引用，调用的是哪个类的方法是多态的！

    2、运行时多态的前提

          (1)继承或实现；

          (2)重写方法

          (3)向上转型，然后调用重写方法

    3、多态注意事项

          (1)属性不是多态的------由引用类型来确定调用的是哪个属性

          实例:        

public class Test {
	public static void main(String[] args) {
		B b = new B();
		A a = b;
		// 当子类和父类中存在同名属性时
		// 由引用类型来决定使用的是哪个类的i
		System.out.println(a.i);
		System.out.println(b.i);

		
		a.fun();
		b.fun();
	}
}

class A {
	int i = 1;
}

class B extends A {
	int i = 2;
}

           (2)static方法不是多态的

          实例:          

public class Test {
	public static void main(String[] args) {
		B b = new B();
		A a = b;
		
		// 引用类型来决定调用的是哪个类的静态方法
		a.fun();
		b.fun();
	}
}

class A {
	public static void fun() {
		System.out.println("A");
	}
}

class B extends A {
	public static void fun() {
		System.out.println("B");
	}
}

           (3)private不是多态的

          实例:

public class Test {
	public static void main(String[] args) {
		A a = new B();
		a.fun();//因为A类中fun()方法是private的，所以外界不能调用，编译不通过！
	}
}

class A {
	private void fun() {
		System.out.println("A");
	}
}

class B extends A {
	public void fun() {
		System.out.println("B");
	}
}

总结:多态提高了代码的重用性，提倡了java中的高内聚低耦合特点，增加了代码的扩展性。

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