java的三大特性，封装，继承，多态

时间：2016-04-16 15:26:48 阅读：186 评论：0 收藏：0 [点我收藏+]

标签：

封装

Java代码

/**
* 所谓封装，就是将对象具有的成员变量和成员函数包装和隐藏起来，让外界无法直接使用，
* 被封装的成员只能通过某些特定的方式才能访问。
* 实现封装有两个步骤：
* 1、将不能暴露的成员隐藏起来，我们就不能让其在类的外部被直接访问或赋值。
* 实现方法是将该成员定义为私有的，在成员定义前加上private访问权限修饰符。
* 2、用公共方法来暴露对该隐藏成员的访问，可以给成员加上public修饰符，将该成员定义为公共的
*/
package com.study.feature;
/**
*
* @className ：Package
* @package : com.study.feature
* @Description ：封装性的测试
* @author：lgf
* @date ：2012 三月 12 10:20:35
* @version : 1.0
*/
public class Package {
// 使用private隐藏
private String strValue;
// 通过get和set进行访问
public String getStrValue() {
return this.strValue;
}
public void setStrValue(String strValue) {
this.strValue = strValue;
}
}

继承
父类 ExtendsFather.java

Java代码

/**
* 继承是一种联结类的层次模型，并且允许和鼓励类的重用，它提供了一种明确表述共性的方法。
* 对象的一个新类可以从现有的类中派生。
* 1. 为什么要使用继承？
* a.提高程序的扩展性。
b.提高了代码的重用性。
2. 子类能继承到父类的那些方法和属性
第一种：所有的属性和方法都被子类继承到了。
第二种：
a、子类和父类在同一个包下：
公有的受保护的属性和方法被子类继承到了。
b、子类和父类不在同一个包下：
公有的方法和属性被子类继承到了。
3. 子类的对象能调用父类的那些方法和属性？
a、子类和父类在同一个包下：
公有的受保护的属性和方法能被子类调用。
b、子类和父类不在同一个包下：
公有的方法和属性能被子类调用。
在类和抽象类中，默认的就是受保护的。
在接口中，默认的就是公有的。
*/
package com.study.feature;
/**
* 父类
* @className ：ExtendsFather
* @package : com.study.feature
* @Description ：继承测试
* @author：lgf
* @date ：2012 三月 12 10:33:02
* @version : 1.0
*/
public class ExtendsFather {
// 定义不同四种修饰符的属性
private String privateValue;
protected String protectedValue;
String defaultValue;
public String publicValue;
// 定义不同四种修饰符的方法
private void privateFunction(){
System.out.println("privateFunction");
}
protected void protectedFunction(){
System.out.println("protectedFunction");
}
void defaultFunction(){
System.out.println("defaultFunction");
}
public void publicFunction(){
System.out.println("publicFunction");
}
}

同包下的子类 ExtendsChildrenSamePackage.java

Java代码

package com.study.feature;
/**
*
*
* @className ：ExtendsChildrenSamePackage
* @package : com.study.feature
* @Description ：同一个包下面的继承关系
* @author：lgf
* @date ：2012 三月 12 10:51:23
* @version : 1.0
*/
public class ExtendsChildrenSamePackage extends ExtendsFather{
public static void main(String[] args) {
ExtendsFather children = new ExtendsChildrenSamePackage();
//children.privateValue = "no"; 无法访问到
children.defaultValue = "ok";
children.protectedValue = "ok";
children.publicValue = "ok";
//除了private修饰的方法,其他都继承到了
//children.privateFunction();
children.defaultFunction();
children.protectedFunction();
children.publicFunction();
}
}

不同包下的子类 ExtendsChildrenOtherPackage.java

Java代码

/**
*
*/
package com.study.featureSecond;
import com.study.feature.ExtendsFather;
/**
*
* @className ：ExtendsChildrenOtherPackage
* @package : com.study.featureSecond
* @Description ：不同包下面的继承关系
* @author：lgf
* @date ：2012 三月 12 10:50:47
* @version : 1.0
*/
public class ExtendsChildrenOtherPackage extends ExtendsFather{
public static void main(String[] args) {
ExtendsFather children = new ExtendsChildrenOtherPackage();
//children.privateValue = "no"; 无法访问到
//children.defaultValue = "no"; 无法访问到
//children.protectedValue = "no"; 无法访问到
children.publicValue= "ok";
//除了public修饰的方法,其他都未继承到了
//children.privateFunction();
//children.defaultFunction();
//children.protectedFunction();
children.publicFunction();
}
}

重载和重写 ExtendsOverRideLoad.java

Java代码

/**
*
*/
package com.study.feature;
/**
*
* @className ：ExtendsClass
* @package : com.study.feature
* @Description ：重载和重写
* @author：lgf
* @date ：2012 三月 12 11:00:35
* @version : 1.0
*/
public class ExtendsOverRideLoad extends ExtendsFather {
@Override
public void publicFunction() {
//super.publicFunction(); 可以调用父类的方法
System.out.println("Override publicFunction");
}
public void publicFunction(String str) {
//super.publicFunction(); 可以调用父类的方法
System.out.println("overload publicFunction");
}
public static void main(String[] args) {
ExtendsFather child= new ExtendsOverRideLoad();
//Override publicFunction
child.publicFunction();
//child.publicFunction("s"); 仅仅只能使用到父类有的方法,重载的方法无法调用
ExtendsOverRideLoad childSecond = new ExtendsOverRideLoad();
//Override publicFunction
childSecond.publicFunction();
//overload publicFunction
childSecond.publicFunction("overLoad");
}
}

多态

父类 Animal.java

Java代码

/**
* 1. Java中除了static和final方法外，其他所有的方法都是运行时绑定的
* 2. 构造方法是被隐式声明为static方法
* 3. 动态绑定
* 将一个方法调用和一个方法主体连接到一起称为绑定（Binding）。
* 根据绑定的时机不同，可将绑定分为“早期绑定”和“后期绑定”两种。
* 如果在程序运行之前进行绑定（由编译器和链接程序完成），称为早期绑定。
* 如果在程序运行期间进行绑定，称为后期绑定，后期绑定也称为“动态绑定”或“运行时绑定”。
* 在Java中，多态性是依靠动态绑定实现的，即Java虚拟机在运行时确定要调用哪一个同名方法。
*
* 4. 多态总结
* 一、使用父类类型的引用指向子类的对象
* 二、该引用只能调用父类中定义的方法和变量
* 三、如果子类中重写了父类中的一个方法，那么在调用这个方法的时候，
* 将会调用子类中的这个方法；（动态连接、动态调用）
* 四、变量不能被重写（覆盖），”重写“的概念只针对方法，
* 如果在子类中”重写“了父类中的变量，那么在编译时会报错。
* 5. 多态详解多态是通过:
* 5.1 接口和实现接口并覆盖接口中同一方法的几不同的类体现的
* 2 父类和继承父类并覆盖父类中同一方法的几个不同子类实现的.
*
* 6. 一个类型引用只能引用引用类型自身含有的方法和变量
*/
package com.study.feature;
/**
* @className ：Animal
* @package : com.study.feature
* @Description ：多态的测试
* @author：lgf
* @date ：2012 三月 12 13:50:36
* @version : 1.0
*/
public class Animal {
public void eat(){
System.out.println("eating");
}
}

多态实现

Java代码

/**
*
*/
package com.study.feature;
/**
*
* @className ：Cat
* @package : com.study.feature
* @Description ：猫
* @author：lgf
* @date ：2012 三月 12 13:54:01
* @version : 1.0
*/
public class Cat extends Animal{
public void eat(){
System.out.println("eating fish");
}
}

Java代码

/**
*
*/
package com.study.feature;
/**
*
* @className ：Dog
* @package : com.study.feature
* @Description ：狗
* @author：lgf
* @date ：2012 三月 12 13:55:38
* @version : 1.0
*/
public class Dog extends Animal{
public void eat(){
System.out.println("eating Bone");
}
}

结果

Java代码

/**
*
*/
package com.study.feature;
/**
*
* @className ：Main
* @package : com.study.feature
* @Description ：多态测试
* @author：lgf
* @date ：2012 三月 12 13:57:11
* @version : 1.0
*/
public class Main {
public static void main(String[] args) {
Animal animal = null;
animal = new Animal();
animal.eat();//eating
Animal cat = new Cat();
cat.eat();//eating fish
Animal dog = new Dog();
dog.eat();//eating Bone
}
}

例子2

Java代码

/**
*
*/
package com.study.feature;
/**
*
* @className ：Father
* @package : com.study.feature
* @Description ：多态
* @author：lgf
* @date ：2012 三月 12 14:53:41
* @version : 1.0
*/
public class Father {
public void functionOne(){
functionSecond();
}
public void functionSecond(){
System.out.println("Father functionSecond");
}
}

Java代码

/**
*
*/
package com.study.feature;
/**
*
* @className ：Children
* @package : com.study.feature
* @Description ：测试
* @author：lgf
* @date ：2012 三月 12 14:55:15
* @version : 1.0
*/
public class Children extends Father{
public void functionSecond(){
System.out.println("Children functionSecond");
}
public static void main(String[] args) {
Father c = new Children();
c.functionOne();//Children functionSecond
}
}

java的三大特性，封装，继承，多态

标签：

原文地址：http://www.cnblogs.com/caimuqing/p/5398415.html

踩

(0)

评论一句话评论（0）

分享档案

更多>

2021年07月29日 (22)
2021年07月28日 (40)
2021年07月27日 (32)
2021年07月26日 (79)
2021年07月23日 (29)
2021年07月22日 (30)
2021年07月21日 (42)
2021年07月20日 (16)
2021年07月19日 (90)
2021年07月16日 (35)

周排行