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

本是古典何须时尚 2022-04-01 11:56 310阅读 0赞

\----------- [android培训][android]、[java培训][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培训][android]、[java培训][java]、java学习型技术博客、期待与您交流！ ------------

[android]: http://edu.csdn.net/heima/
[java]: http://edu.csdn.net/heima