篇一：java 三大特性--封装、继承和多态理解
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
/**
* 继承是一种联结类的层次模型，并且允许和鼓励类的重用，它提供了一种明确表述共性的方法。
* 对象的一个新类可以从现有的类中派生。
* 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;
publicString 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 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 /**
*
*/
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
/**
*
*/
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
/**
* 1. Java中除了static和final方法外，其他所有的方法都是运行时绑定的
* 2. 构造方法是被隐式声明为static方法
* 3. 动态绑定
* 将一个方法调用和一个方法主体连接到一起称为绑定（Binding）。
篇二：Java语言的三大特性即是：封装、继承、多态
Java语言的三大特性即是：封装、继承、多态
首先先简单的说一下其3大特性的定义：
封装：隐藏对象的属性和实现细节，仅对外公开接口,控制在程序中属性的读和修改的访问级别。将抽象得到的数据和行为（或功能）相结合，形成一个有机的整体，也就是将数据与操作数据的源代码进行有机的结合，形成“类”，其中数据和函数都是类的成员。封装的目的是增强安全性和简化编程，使用者不必了解具体的实现细节，而只是要通过外部接口，一特定的访问权限来使用类的成员。封装的基本要求是: 把所有的属性私有化，对每个属性提供getter和setter方法，如果有一个带参的构造函数的话，那一定要写一个不带参的构造函数。在开发的时候经常要对已经编写的类进行测试，所以在有的时候还有重写toString方法，但这不是必须的。
继承：通过继承实现代码复用。Java中所有的类都是通过直接或间接地继承java.lang.Object类得到的。继承而得到的类称为子类，被继承的类称为父类。子类不能继承父类中访问权限为private的成员变量和方法。子类可以重写父类的方法，及命名与父类同名的成员变量。但Java不支持多重继承，即一个类从多个超类派生的能力。在开发中尽量减少继承关系，这样做是为了把程序的耦合度降低。
多态：多态又分为设计时多态和运行时多态，例如重载又被称为设计时多态，而对于覆盖或继承的方法，JAVA运行时系统根据调用该方法的实例的类型来决定选择调用哪个方法则被称为运行时多态。总而言之，面向对象的设计的典型特点就是继承，封装和多态，这些特点也是面向对象之所以能如此盛行的关键所在。
以上就是java三大特性的基本含义，大家理解一下就行了，千万别背啊！接下来我们通过一个例子来完美的解释一下java的3大特性。
用java做一个简单计算器；
import java.io.*;
class OperationAttridute
{
private double numberA=0;
private double numberB=0;
private double result=0;
public double setNumberA(double i)
{
return numberA=i;
}
public double getNumberA()
{
return numberA;
}
public double setNumberB(double j)
{
return numberB=j;
}
public double getNumberB()
{
return numberB;
}
public double setResult(double z)
{
return result=z;
}
public double getResult(double a,double b)
{
return result;
}
}
//将要运算的2个数字和运算结果进行封装。
class OperationA extends OperationAttridute
{
public double getResult(double a,double b)
{
double result=0;
result=a+b;
return result;
}
}
//加法类：继承OperationAttridute类并且覆盖其getResult方法
class OperationS extends OperationAttridute
{
public double getResult(double a,double b)
{
double result=0;
result=a-b;
return result;
}
//减法类：继承OperationAttridute类并且覆盖其getResult方法
class OperationM extends OperationAttridute
{
public double getResult(double a,double b)
{
double result=0;
result=a*b;
return result;
}
}
//乘法类：继承OperationAttridute类并且覆盖其getResult方法
class OperationD extends OperationAttridute
{
public double getResult(double a,double b)
{
double result=0;
if(b==0)
{
Throw new RuntimeException(“被除数不能为0”);
}
result=a/b;
return result;
}
}
//除法类：继承OperationAttridute类并且覆盖其getResult方法，除法要对被除数进行判断并抛出异常
class Operationdo
{
public static Object expression_r(char r)
{
OperationAttridute oa=new OperationAttridute();
switch(r)
{
case '+':
oa=new OperationA();
break;
case '-':
oa=new OperationS();
break;
case '*':
oa=new OperationM();
break;
case '/':
oa=new OperationD();
篇三：实验报告二 Java类的封装、继承、多态
Java实验二 类的封装、继承、多态
一. 实验目的
1. 复习、理解OOP的三大特征——封装、继承和多态。
2. 学会使用Java编写简单的类。理解类的属性和方法。
3．掌握关键字private, protected, public的作用，掌握静态类，内部类的概念。
4. 掌握多态的概念。
二. 实验内容
2.1程序要求
1． 分别编写两个类Point2D，Point3D来表示二维空间和三维空间的点，使之满足下列要求：
（1） Point2D有两个整型成员变量x, y (分别为二维空间的X,Y方向坐
标)，Point2D的构造方法要实现对其成员变量x, y的初始化。
（2） Point2D有一个void型成员方法offset(int a, int b)，它可以实现
Point2D的平移。
（3） Point3D是Point2D的直接子类，它有有三个整型成员变量x,y,z
(分别为三维空间的X,Y,Z方向坐标)，Point3D有两个构造方法：Point3D(int x,int y,int z)和Point3D(Point2D p,int z)，两者均可实现对Point3D的成员变量x, y,z的初始化。
（4） Point3D有一个void型成员方法offset(int a, int b,int c)，该方
法可以实现Point3D的平移。
（5） 在Point3D中的主函数main()中实例化两个Point2D的对象
p2d1，p2d2，打印出它们之间的距离，再实例化两个Point3D的对象p3d1，p3d2，打印出他们之间的距离。
提示：java.lang..Math.sqrt()方法
2． 创建一个数组，随机生成Point2D或者Point3D的对象放于其中。最后依次调用数组中每个对象的“打印方法”，显示数组中存储的对象是什么。
提示：java.lang..Math.random()方法 或者 java.util.Random类
2.2 设计工作
设计思路：
构造Point 2D类，私有成员x,y存放2D点位置坐标，构造函数传入坐标值。Offset()函数平移2D点，get_x(),get_y()分别返回x,y坐标。Print()函数打印
2D点坐标。再构造继承了2D类的Point3D类，将上述2D点函数覆盖扩充到3D。创建Point 2D的对象数组，存放随机产生的Point 2D或Point 3D对象。用 java.util.Random方法产生随机数。
类图：
point 2D：
Protected int x, y; //变量
Point 2D(int x, int y); //构造方法
Void offest(int a, int b); //位移2D
Int get_x();
Int get_y();
Void print();
Point 3D
Int z; //变量
Point3D(int x,int y,int z); //构造方法
Point3D(point2D p,int z); //构造方法
Void offest(int a,int b,intc); //位移3D
Int get_z();
Void print()；
Point 2D 代码：
class Point2D{
protected int x,y;
Point2D(int X,int Y){
x=X;
y=Y;
}
void offset(int a,int b){
x+=a;
y+=b;
}
int get_x(){return x;}
int get_y(){return y;}
void print(){
System.out.println
（"坐标为:"+this.get_x()+" "+this.get_y());
}
Point 3D代码：
class Point3D{
protected int x,y,z;
Point3D(int X,int Y,int Z){
x=X;
y=Y;
z=Z;
}
void offset(int a,int b,int c){
super(a,b);
z+=c;
}
int get_x(){return x;}
int get_y(){return y;}
int get_z(){return z;}
void print(){
System.out.println
（"坐标为:"+this.get_x()+" "+this.get_y()+" "+this.get_z()); }
}
三. 思考题
1．什么是类的多态性。
同一操作作用于不同的对象，可以有不同的解释，产生不同的执行结果，这就是多态性。
? 编译时的多态性：编译时的多态性是通过重载来实现的。对于非虚
的成员来说，系统在编译时，根据传递的参数、返回的类型等信息
决定实现何种操作。
? 运行时的多态性：运行时的多态性就是指直到系统运行时，才根据
实际情况决定实现何种操作。
四．程序代码
import java.util.Scanner; //导入util包中的Scannner类
class Point2D{
protected int x,y;
Point2D(int X,int Y){ //有参数的构造方法
x=X;
y=Y;
}
void offset(int a,int b){ //位移Point2D
x+=a;
y+=b;
}
int get_x(){return x;}
int get_y(){return y;}
void print(){
System.out.println("坐标为:"+this.get_x()+" "+this.get_y());
}
}
class Point3D extends Point2D{//3d的继承
int z;
Point3D(int X,int Y,int Z){//3D的有参构造函数
super(X,Y);
z=Z;
}
void offset(int a,int b,int c){//方法的重载，参数个数不同
x+=a;
y+=b;
z+=c;
}
int get_z(){return z;}
void print(){
System.out.println("坐标为:"+this.get_x()+" "+this.get_y()
+" "+this.get_z());
}
}
public class SpacePoint{
public static void main(String[]args){
int x,y,z;
float d;
int i;
Scanner s = new Scanner(System.in);
System.out.println("输入X1_2D,Y1_2D");
x=s.nextInt();
y=s.nextInt();
Point2D p2d1=new Point2D(x,y);//初始化对象
System.out.println("输入X2_2D,Y2_2D");
x=s.nextInt();
y=s.nextInt();
Point2D p2d2=new Point2D(x,y); //初始化对象
System.out.println("输入X1_3D,Y1_3D,Z1_3D");
x=s.nextInt();
y=s.nextInt();
z=s.nextInt();
Point3D p3d1=new Point3D(x,y,z); //初始化对象
System.out.println("输入X2_3D,Y2_3D,Z2_3D");
x=s.nextInt();
y=s.nextInt();
z=s.nextInt();
Point3D p3d2=new Point3D(x,y,z); //初始化对象
d=(float)Math.sqrt((p2d1.get_x()-p2d2.get_x())*(p2d1.get_x()-p2d2.get_x())+(p2d1.get_y()-p2d2.get_y())*(p2d1.get_y()-p2d2.get_y()));
System.out.println("2D点距离："+d);
d=(float)Math.sqrt((p3d1.get_x()-p3d2.get_x())*(p3d1.get_x()-p3d2.get_x())+
(p3d1.get_y()-p3d2.get_y())*(p3d1.get_y()-p3d2.get_y())+
(p3d1.get_z()-p3d2.get_z())*(p3d1.get_z()-p3d2.get_z()));
System.out.println("3D点距离："+d);
Point2D array[]=new Point2D[10];//初始化数组对象
for(i=0;i<10;i++){
x=(int)(10*Math.random());
y=(int)(10*Math.random());
z=(int)(10*Math.random());
if(10*Math.random()>5){
Point3D p=new Point3D((int)(10*Math.random()),
(int)(10*Math.random()),
(int)(10*Math.random()));
array[i]=p;
}
else{
Point2D p=new Point2D((int)(10*Math.random()),
(int)(10*Math.random()));//初始化对象并赋初值
array[i]=p;
}
}
for(i=0;i<10;i++){
System.out.print("第"+(i+1)+"个点");
array[i].print();
}
}
}
《java封装继承多态理解3000字论文word》
由：免费论文网互联网用户整理提供,链接地址：
http://m.csmayi.cn/show/93867.html
转载请保留,谢谢!
- 上一篇：风筝作文700字
- 下一篇：IT行业职业生涯规划3000字