实验三 Java面向对象高级编程

合集下载

java面向对象技术实验

面向对象技术
东北大学网络教育学院
12
编译和运行
保存源文件
设定搜索路径 path 编译运行
– 注意文件名和大小写 – 文件的扩展名.java
– javac HelloWorldApp.java – Java HelloWorldApp
东北大学网络教育学院 4
面向对象技术
编译和运行
面向对象技术
东北大学网络教育学院
5
实验一
1 、用默认构建器创建一个类（没有自变量），用用默认构建器创建一个类（没有自变量），），用它打印一条消息。创建属于这个类的一个对象。它打印一条消息。创建属于这个类的一个对象。 2、在练习的基础上增加一个过载的构建器，令其的基础上增加一个过载的构建器，、在练习1的基础上增加一个过载的构建器采用一个String自变量，并随同自己的消息打印自变量，采用一个自变量出来。出来。 3、以练习创建的类为基础上，创建属于它的对象创建的类为基础上，、以练习2创建的类为基础上句柄的一个数组，句柄的一个数组，但不要实际创建对象并分配到数组里。运行程序时，数组里。运行程序时，注意是否打印出来自构建器调用的初始化消息。器调用的初始化消息。 4、创建同句柄数组联系起来的对象，最终完成练、创建同句柄数组联系起来的对象，习3。。
面向对象技术
东北大学网络教育学院
11
实验五
1、创建一个有文字字段和三个按钮的程序片。当我们、创建一个有文字字段和三个按钮的程序片。按下每个按钮时，使不同的文字显示在文字段中。按下每个按钮时，使不同的文字显示在文字段中。 2、增加一个复选框到练习1创建的程序中，捕捉事件、增加一个复选框到练习创建的程序中，创建的程序中，并插入不同的文字到文字字段中。并插入不同的文字到文字字段中。 3、创建一个应用程序并将本章所有的组件增加主框架、包括菜单和对话框。中，包括菜单和对话框。 4、完成计算器程序的简单功能。、完成计算器程序的简单功能。

Java面向对象高级编程

2
6.1.2 类的继承-类继承的实现
• ⒈继承的实现
– 格式： – [修饰符] class 新定义的类名 [extends 父类名] – 例：class SubRectangleA extends RectangleA{}
• ⒉子类继承父类的原则
– ⑴直接子类继承那些被声明为public或protected的直接父类成员。
Java 基础培训
第6章 Java面向对象高级编程
6.1.1 类的继承-继承的概念
⒈继承是程序中两个类间的一种关系
⒉指明继承关系后，父类中的属性(成员)就无须在子类中重复描述，从而实现了一定程度的代码的重用
类：B 成员属性成员方法
类：A(继承)
直接超类、直接父类子类、次类、衍生类
⒊在Java的继承层次中，一个父类可以有多个直接子类，但一个子类只能有一个直接父类，即Java不支持多重继承
– 区分形参名及成员变量名 – 可用this来调用它所在的类本身的构造方法
• ⒉super—代表它所在类的直接父类对象
– 访问父类的成员变量及方法 – 调用父类的构造方法
7
6.2.1 类的多态-方法的重载
• ⒈在同一个类中，以相同的名字定义多个方法，只是参数列表不同，即为方法的重载。
• ⒉它实现了Java编译时的多态性(静态多态性)。也就是说，程序可以按参数决定调用对应方法，而此决定是由编译器来做的，即在调用时，Java 将根据实参个数或参数类型选择匹配的方法。
8
6.3.1 接口-接口的概念
• ⒈接口又称界面，英文名称为interface，它是用来组织应用中的各类并调节它们的相互关系的一种结构，是用来实现类间多重继承的结构。

JAVA程序设计3 java面向对象(2)

equals方法 • boolean equals (Object o) • equals方法用于判断两个对象是否相等 • 在不属于同一类型的两个对象之间调用equals 方法通常会返回false • equals方法的作用同==运算符既有区别又有联系 • 在判断两个对象是否相等时应使用equals方法而非==运算符
class A { int x; void func() { System.out.println("func() in A"); } void foo() { System.out.println("foo() in A"); } } class B extends A { void func() { System.out.println("func() in B"); } }
3.2.14.3 类的继承
• 子类将拥有(不一定可以访问所有)父类的所有变量和方法 class A { int x; void func() { System.out.println("func() in A"); } } class B extends A { }
3.2.14.4 类的继承
public class Test { public static void main(String[] args) { B b = new B(); b.x = 4; // if x in A is private?? System.out.println("b.x = " + b.x); b.func(); } }
3.2.19.3 Object类中的主要方法
• equals方法在默认情况下具有与等号操作符一样的功能 Human h1 = new Human(); Human h2 = new Human(); Huamn h3 = h1; h1.equals(h2)的结果为false h1.equals(h3)的结果为true

实验三 Java的面向对象技术编程

实验三 Java的面向对象技术编程1.实验时间和地点2.实验内容2.1 设计一个类，具有以下功能：2.1.1 判断某整数是否为偶数；2.1.2 判断某整数是否为正数；2.1.3 得到两个整数中较大的数；2.1.4 对一个数组进行排序，要求用重载实现对int型和double型两种数组的排序；2.1.5 求一个一维数组中第一次出现元素a的位置，要求用重载实现对int型a元素、double 型元素a元素的操作；2.1.6 求一个一维数组中第i次出现元素a的位置，要求用重载实现对int型元素、double 型a元素的操作；2.2 设计一个加法类，完成两个数的和、三个数的和、四个数的和；2.3 设计一个计算类，对上题进行继承，除完成上题功能外，还提供减、乘和除的操作；2.4 设计一个面积周长类，派生出矩形面积周长类、圆形面积周长类两个子类，用于求解相应图形的面积和周长，各种形状还具备颜色的属性；2.5 自学jdk API参考手册中的String和StringBuffer类，并至少验证这两个类中各自五种不同名的方法；2.6 设计一个类，对多态性进行说明；3.实验源程序3.1 源程序如下：//ManipulateOnNumeral.javaimport java.util.*;public class ManipulateOnNumeral {//判断某整数是否为偶数static boolean T1 = true;static boolean F1 = false;static boolean JudgeEvenNumber(int a){if(a%2==0){return T1;}else{return F1;}}//判断某整数是否为正数static boolean JudgeInteger(int b){if(b>0){return T1;}else{return F1;}}//输出两个数中较大的一个数static double Bigerone(double c,double d){if(c>d){return c;}else{return d;}}//对一个数组进行排序，要求用重载实现对int型和double型两种数组的排序void Sort(int[] e){for(int i=0;i<e.length-1;i++){for(int j=i+1;j<e.length;j++){if(e[i]>e[j]){int temp=e[i];;e[i]=e[j];e[j]=temp;}}}System.out.println("排序后的数组为："+Arrays.toString(e));}void Sort(double[] f){for(int i=0;i<f.length-1;i++){for(int j=i+1;j<f.length;j++){if(f[i]>f[j]){double temp=f[i];;f[i]=f[j];f[j]=temp;}}}System.out.println("排序后的数组为："+Arrays.toString(f));}//求一个一维数组中第一次出现元素a的位置，要求用重载实现对int型a元素、double型a元素的操作static int FirstPlace(int a,int[] s){for(int i=0;i<s.length;i++){if(s[i]==a){return i;}}return -1;}static int FirstPlace(double a,double[] t){for(int i=0;i<t.length;i++){if(t[i]==a){return i;}}return -1;}//求一个一维数组中第i次出现元素a的位置，要求用重载实现对int型a元素、double型a元素的操作public static int Place(int a, int[] s, int i) {for(int j=0,k=0;j<s.length;j++) {if(s[j]==a) {k++;}if(i==k) {return j;}}return -1;}public static int Place(double a,double[] s,int i) {for(int j=0,k=0;j<s.length;j++) {if(s[j]==a) {k++;}if(i==k) {return j;}}return -1;}public static void main(String[] args) {System.out.println("-----判断一个整数是否为偶数----------");System.out.println("请输入一个整数：");Scanner in=new Scanner(System.in);int sc=in.nextInt();System.out.println(ManipulateOnNumeral.JudgeEvenNumber(sc));System.out.println("-----判断一个整数是否为正数----------");System.out.println("请输入一个整数：");Scanner g=new Scanner(System.in);int a=g.nextInt();System.out.println(ManipulateOnNumeral.JudgeInteger(a));System.out.println("-----判断两个数中较大的一个数----------");System.out.println("请输入两个数：");Scanner f=new Scanner(System.in);double b=f.nextDouble();double c=f.nextDouble();System.out.println("较大数为："+ManipulateOnNumeral.Bigerone(b,c));System.out.println("-----对一个int型数组排序----------");int[] d=new int[5];System.out.println("请输入5个int类型的数：");Scanner h=new Scanner(System.in);for(int i=0;i<d.length;i++)d[i]=h.nextInt();Arrays.sort(d);System.out.println("排序后数组:" + Arrays.toString(d));System.out.println("-----对一个double型数组排序----------");double[] e=new double[5];System.out.println("请输入5个double类型的数");Scanner x=new Scanner(System.in);for(int i=0;i<e.length;i++)e[i]=h.nextDouble();Arrays.sort(e);System.out.println("排序后数组:" + Arrays.toString(e));System.out.println("---求一个int型一维数组中第一次出现元素a的位置---");int[] s=new int[10];System.out.println("请输入10个int类型的数：");Scanner p1=new Scanner(System.in);for(int i=0;i<s.length;i++)s[i]=p1.nextInt();System.out.println("请输入要定位的数：");Scanner p2=new Scanner(System.in);int x1=p2.nextInt();System.out.println("第一次出现元素"+x1+"的位置为："+ManipulateOnNumeral.FirstPlace(x1, s));System.out.println("---求一个double型一维数组中第一次出现元素a的位置---");double[] t=new double[10];System.out.println("请输入10个double类型的数：");Scanner q1=new Scanner(System.in);for(int i=0;i<t.length;i++)t[i]=q1.nextDouble();System.out.println("请输入要定位的数：");Scanner q2=new Scanner(System.in);double x2=q2.nextDouble();System.out.println("第一次出现元素"+x2+"的位置为："+ManipulateOnNumeral.FirstPlace(x2, t));System.out.println("---求一个int型一维数组中第i次出现元素a的位置---");int[] m=new int[10];System.out.println("请输入10个int类型的数：");Scanner r1=new Scanner(System.in);for(int i=0;i<m.length;i++)m[i]=r1.nextInt();System.out.println("请输入要定位的数：");Scanner r2=new Scanner(System.in);int x3=r2.nextInt();System.out.println("请输入要查找第几次出现a的位置！");Scanner r3 = new Scanner(System.in);int x4 = r3.nextInt();System.out.println("第"+x4+"出现元素"+x3+"的位置为："+ManipulateOnNumeral.Place(x3, m,x4));System.out.println("---求一个double型一维数组中第i次出现元素a的位置---");double[] n=new double[10];System.out.println("请输入10个double类型的数：");Scanner t1=new Scanner(System.in);for(int i=0;i<n.length;i++)n[i]=t1.nextDouble();System.out.println("请输入要定位的数：");Scanner t2=new Scanner(System.in);double x5=t2.nextDouble();System.out.println("请输入要查找第几次出现a的位置！");Scanner t3 = new Scanner(System.in);int x6 = t3.nextInt();System.out.println("第"+x6+"出现元素"+x5+"的位置："+ManipulateOnNumeral.Place(x5, n, x6));}}3.2 源程序如下：//Addition.javapublic class Addition {static double addition (double a, double b) {return a + b;}static double addition (double a, double b, double c){return a + b + c;}static double addition (double a, double b, double c, double d){ return a + b + c + d;}}//UseAddition.javaimport java.util.Scanner;public class UseAddition{public static void main(String[] args) {System.out.println("----------测试加法运算---------------");//两数相加System.out.println("请输入两个数字：");Scanner sc=new Scanner(System.in);double a1=sc.nextDouble();double b1=sc.nextDouble();System.out.println(a1+"+"+b1+"="+Addition.addition(a1, b1));//三数相加System.out.println("请输入三个数字：");Scanner in=new Scanner(System.in);double a2=in.nextDouble();double b2=in.nextDouble();double c2=in.nextDouble();System.out.println(a2+"+"+b2+"+"+c2+"="+Addition.addition(a2,b2,c2)); //四数相加System.out.println("请输入四个数字：");Scanner put=new Scanner(System.in);double a3=in.nextDouble();double b3=in.nextDouble();double c3=in.nextDouble();double d3=in.nextDouble();System.out.println(a3+"+"+b3+"+"+c3+"+"+d3+"="+Addition.addition(a3, b3,c3,d3));}}3.3 源程序如下：//Method.java//减法class Subtraction extends Addition{static double subtraction(double a, double b){return a-b;}static double subtraction(double a, double b, double c){return a-b-c;}static double subtraction(double a, double b, double c, double d){ return a-b-c-d;}}//乘法class Multiplication extends Addition{static double multiplication(double a, double b){return a*b;}static double multiplication(double a, double b, double c){return a*b*c;}static double multiplication(double a, double b, double c, double d){ return a*b*c*d;}}//除法class Division extends Addition{static double division(double a, double b){return a/b;}static double division(double a, double b, double c){return a/b/c;}static double division(double a, double b, double c, double d){ return a/b/c/d;}}//UseMethod.javaimport ng.reflect.Method;import java.util.Scanner;//设计一个计算类，对上题进行继承，除完成上题加法功能外，还提供减、乘和除的操作public class UseMethod {public static void main(String[] args) {System.out.println("----------加法运算---------------");//两数相加System.out.println("请输入两个数字：");Scanner a=new Scanner(System.in);double a1=a.nextDouble();double b1=a.nextDouble();System.out.println(a1+"+"+b1+"="+Addition.addition(a1, b1));//三数相加System.out.println("请输入三个数字：");Scanner b=new Scanner(System.in);double a2=b.nextDouble();double b2=b.nextDouble();double c2=b.nextDouble();System.out.println(a2+"+"+b2+"+"+c2+"="+Addition.addition(a2,b2,c2)); //四数相加System.out.println("请输入四个数字：");Scanner c=new Scanner(System.in);double a3=c.nextDouble();double b3=c.nextDouble();double c3=c.nextDouble();double d3=c.nextDouble();System.out.println(a3+"+"+b3+"+"+c3+"+"+d3+"="+Addition.addition(a3, b3,c3,d3));System.out.println("----------减法运算---------------");//两数相减System.out.println("请输入两个数字：");Scanner d=new Scanner(System.in);double a4=d.nextDouble();double b4=d.nextDouble();System.out.println(a4+"-"+b4+"="+Subtraction.subtraction(a4, b4)); //三数相减Subtraction E=new Subtraction();System.out.println("请输入三个数字：");Scanner e=new Scanner(System.in);double a5=e.nextDouble();double b5=e.nextDouble();double c5=e.nextDouble();System.out.println(a5+"-"+b5+"-"+c5+"="+Subtraction.subtraction(a5,b5,c 5));//四数相减System.out.println("请输入四个数字：");Scanner f=new Scanner(System.in);double a6=f.nextDouble();double b6=f.nextDouble();double c6=f.nextDouble();double d6=f.nextDouble();System.out.println(a6+"-"+b6+"-"+c6+"-"+d6+"="+Subtraction.subtraction(a6, b6,c6,d6));System.out.println("----------乘法运算---------------");//两数相乘System.out.println("请输入两个数字：");Scanner g=new Scanner(System.in);double a7=g.nextDouble();double b7=g.nextDouble();System.out.println(a7+"*"+b7+"="+Multiplication.multiplication(a7, b7));//三数相乘System.out.println("请输入三个数字：");Scanner h=new Scanner(System.in);double a8=h.nextDouble();double b8=h.nextDouble();double c8=h.nextDouble();System.out.println(a8+"*"+b8+"*"+c8+"="+Multiplication.multiplication(a 8,b8,c8));//四数相乘System.out.println("请输入四个数字：");Scanner i=new Scanner(System.in);double a9=i.nextDouble();double b9=i.nextDouble();double c9=i.nextDouble();double d9=i.nextDouble();System.out.println(a9+"*"+b9+"*"+c9+"*"+d9+"="+Multiplication.multiplic ation(a9, b9,c9,d9));System.out.println("----------除法运算---------------");//两数相除System.out.println("请输入两个数字：");Scanner j=new Scanner(System.in);double a10=j.nextDouble();double b10=j.nextDouble();System.out.println(a10+"/"+b10+"="+Division.division(a10, b10));//三数相除System.out.println("请输入三个数字：");Scanner k=new Scanner(System.in);double a11=k.nextDouble();double b11=k.nextDouble();double c11=k.nextDouble();System.out.println(a11+"/"+b11+"/"+c11+"="+Division.division(a11,b11,c1 1));//四数相除System.out.println("请输入四个数字：");Scanner l=new Scanner(System.in);double a12=l.nextDouble();double b12=l.nextDouble();double c12=l.nextDouble();double d12=l.nextDouble();System.out.println(a12+"/"+b12+"/"+c12+"/"+d12+"="+Division.division(a1 2, b12,c12,d12));}}3.4 源程序如下：//Shape.javapublic abstract class Shape {private double Perimeter;//定义周长private double Area;//定义面积private String Colour;//定义颜色public double getPerimeter( ) {return this.Perimeter;}public double getArea( ) {return this.Area;}public String getColour(){return this.Colour;}public void printPerimeter( ) {System.out.println("周长 = " + this.getPerimeter( ));}public void printArea( ) {System.out.println("面积 = " + this.getArea( ));}public void printColour( ) {System.out.println("颜色 = " + this.getColour( ));}public abstract double ComputePerimeter( ) ;public abstract double ComputeArea( );public abstract String MColour();}//Rectangle.javapublic class Rectangle extends Shape {private double a,b;private String colour;Rectangle(double a, double b, String colour) {this.setSides(a, b);this.colour=colour;}public void setSides(double a, double b) {if(a<0||b<0) {System.out.println("矩形边长必须大于0");return ;}this.a = a;this.b = b;}public void printPerimeter( ) {System.out.println("矩形的周长=" + putePerimeter()); }public void printArea( ) {System.out.println("矩形的面积=" + puteArea());}public void printColour( ) {System.out.println("矩形的颜色=" + this.MColour());}public double ComputePerimeter( ) {return 2*this.a + 2*this.b;}public double ComputeArea( ) {return this.a*this.b;}public String MColour( ){return this.colour;}}//Circle.javapublic class Circle extends Shape {private double radius;private String colour;Circle(double radius,String colour) {this.setRadius(radius);this.colour=colour;}public void setRadius(double radius) {if( radius <=0) {System.out.println("半径必须大于0");return ;}this.radius = radius;}public void printPerimeter( ) {System.out.println("圆形的周长=" + putePerimeter());}public void printArea( ) {System.out.println("圆形的面积=" + puteArea());}public void printColour( ) {System.out.println("圆形的颜色=" + this.MColour());}public double ComputePerimeter() {return 2*Math.PI*this.radius;}public double ComputeArea() {return Math.PI*Math.pow(radius, 2);}public String MColour( ){return this.colour;}}//TestShape.javaimport java.util.Scanner;public class TestShape {public static void main(String [ ] args) { System.out.println("请输入矩形的长和宽：");Scanner sc = new Scanner(System.in);double a = sc.nextDouble();double b = sc.nextDouble();System.out.println("请输入矩形的颜色：");Scanner sd = new Scanner(System.in);String c =sd.nextLine();Shape s1 = new Rectangle(a,b,c);s1.printPerimeter();s1.printArea();s1.printColour();System.out.println("请输入圆形的半径：");Scanner se = new Scanner(System.in);double d = se.nextDouble();System.out.println("请输入圆形的颜色：");Scanner sf = new Scanner(System.in);String e =sf.nextLine();Shape s2 = new Circle(d,e);s2.printPerimeter();s2.printArea();s2.printColour();}}3.5 源程序如下：//StringTest.java//验证String类中五种不同名的方法public class StringTest {public static void main(String[] args) {String s=new String("insects eaten by birds!");System.out.println("输出的字符串为："+s);System.out.println("字符串长度为："+s.length());String a = ("early ");System.out.println("在index为0处添加early："+a+s);System.out.println("index为5处字符："+s.charAt(5));System.out.println("第一次出现n的位置："+s.indexOf('n'));System.out.println("最后一次出现s的位置："+stIndexOf('s'));System.out.println("将小写字母改为大写字母："+s.toUpperCase());}}/*String类型表示Unicode字符的字符串，该类型的字符串对象时只读的，也就是说，一旦创建了某个字符串对象，那么该字符串对象就不能够被修改。

Java面向对象(高级)

• 要求：必须调用至少一次父类的构造方法，否则父类无法实例化，而要求是实例化子类时先实例化附列，此时就出错了。
二、覆写
1、方法覆写 • 概念：指子类定义了与父类中同名的方法，但被子类覆写的方法不能拥
有比父类方法更加严格的访问权限，可以扩大。 • 覆写方法中访问父类的方法，使用：super.方法名() super代表的是父类。
• 单例模式： 1、单例类只能有一个实例。 2、单例类必须自己创建自己的唯一实例。 3、单例类必须给所有其他对象提供这一实例。
• 工厂模式：工厂是用来生产具体事物的（实例化具体类）地方，不在主方法中去挨个实例化，直接使用工厂帮我实例化。
（1）定义一个水果接口，所有的水果都需要实现该接口。
（2）定义两个水果类，实现该接口：
说明：所有的常量和方法都是public、abstract的，所以接口定义时可以省略这两个关键字，常量还可以省略final和static（接口规定里面的量只能是常量，所以不写也知道）如下：
省略为
• 实现接口的格式：一个子类可以实现多个接口。
举例：一个子类实现接口的例子
• 一个子类可以同时继承抽象类，并实现接口格式：
（2）在子类中扩充功能，比如添加属性，则子类拥有该功能，负责则没有。
• 说明：（1）只允许多层继承，不能多重继承（不能同时有多个父类）
（2）子类不能直接访问父类中的私有成员，可以调用父类中的非私有方法（比如setter和getter 方法）间接操作私有成员。
• 子类对象的实例化过程：
子类对象在实例化之前必须先调用父类中的构造方法后再调用子类自己的构造方法
显式结果：
• 至少要有一个子类的构造方法去调用父类的构造方法，如果子类中有无参数的构造方法，则会自动调用父类的无参数的构造方法（前提是父类中得有无参构造方法），如果子类中没有无参构造方法，则带参数的构造方法必须调用一次父类的构造方法（无参的父构造方法自动调用，有参的则必须super(参数)调用），如果子类中带参数的构造方法想去调用父类中带参数的构造方法则需要使用super(参数)

[工学]Part03-Java面向对象编程高级篇

Example:HideDemo.java
A x = new B();
protected修饰符
protected修饰符用于修饰数据和方法,可以被同一个包中的任何类或不同包中的子类访问.
P1
P2
C1 public int x protected int y int z private int u
: double
+ setRadius (double radius) : v oid
+ getArea ()
: double
+ getPerimeter ()
: double
+ getDiameter ()
: double
Rectangle
- width : double - height : double
}
class B { public void p<int i> { }
}
class B { public void p<int i> { }
}
class A extends B { public void p<int i> { System.out.println<i>; }
}
class A extends B { public void p<double i> { System.out.println<i>; }
静态方法不能被覆盖,如果静态方法在子类中重新定义,那么父类方法将被隐藏.
一旦父类中的方法被覆盖,则不能从子类外部访问被覆盖的方法.在子类中可以使用super引用被覆盖的方法.
Example:Circle.java, Rectangle.java, TestCircleRectangle.java

实验三Java面向对象高级编程

return false;
}
}
public double getBalance() { // getBalance()，用于返回balance的值
return balance;
}
}
Customer1.java:
package com.mybank.domain;
public class Customer1 {//创建Customer1类
2.创建SavingsAccount类，该类是Account类的子类：
·位于包：com.mybank.domain中；
·向SavingsAccount类中添加interestRate实例变量；
·添加一个有两个参数的公有构造方法：initBalance和interestRate。调用父类构造方法传递initBalance参数，并初始化实例变量interestRate；
}
public double accumulateinterest() {// accumulateInterest方法：用于计算客户的利息。
return this.getBalance() * interestrate;
}
}
Checkingaccout.java:
package com.mybank.domain;
public class Checkingaccout extends Account {//创建CheckingAccount类，Account类的子类：
private double overdraftamount;
public Checkingaccout(int balance, double overdraftamount) {//有两个参数的公有构造方法

java 面向对象的程序设计

Java程序设计实验报告班级：电气F1104学号：201123910723姓名：曹俊波指导老师：魏蔚一、实验题目面向对象的程序设计二、实验内容1）完成对象的使用和创建。

2）完成java中多态性中的冲在多态性的验证。

3）掌握抽象类的与接口的作用与用法。

三、实验步骤1）对象的使用实验一的原程序如下：class Point{int x,y;String name="a point";Point(){x=0;y=0;}Point(int x,int y,String name){this.x=x;this.y=y;=name;}int getX(){return x;}int getY(){return y;}void move(int newX,int newY){x=newX;y=newY;}Point newPoint(String name){Point newP=new Point(-x,-y,name);return newP;}boolean equal(int x,int y){if(this.x==x&&this.y==y)return true;elsereturn false;}void print(){System.out.println(name+": x="+x+" y="+y);}}public class UsingObject{public static void main(String args[]){Point p=new Point();p.print();p.move(50,50);System.out.println("****after moving****");System.out.println("Get x and y directly");System.out.println("x="+p.x+" y="+p.y);System.out.println("or Get x and y by calling method");System.out.println("x="+p.getX()+" y="+p.getY());if(p.equal(50,50))System.out.println("I like this point!");elseSystem.out.println("I hate it!");p.newPoint("a new point").print();new Point(10,15,"another new point").print();}}第一步：先在D盘建一个“工作目录”的文件夹。

java面向对象编程实验报告

java面向对象编程实验报告篇一：java面向对象编程实验报告信息工程学院Java程序设计实验/实习报告学院:信息工程学院班级:信息112 姓名:吴连梅学号:XX013305 成绩:A实验二面向对象编程1．实验目的（1）掌握类与对象基本知识；（2）Java中的继承机制及包（package）、接口（interface）等的设计方法；（3）掌握static、this、super等关键字的使用；（4）掌握Java中两种比较器的用法。

2．实验内容实验题 1 定义一个类Book，包含两个属性：一个是private的String类型的属性title、一个是private的float类型的属性listPrice，封装这两个属性的四个方法setTitle（）和getTitle（）、setListPrice( )和geListPrice （）。

基本要求：（1）设计类Book及类BookManagement，在类BookManagement中输出Book类的对象的两个private属性；（2）重写父类的toString（）方法，实现Book类实例的两个属性的输出。

实验过程：新建工程后，在工程下面建立一个包Book，在包下再建立一个Book类，类中包含两个属性，一个是private的String类型的属性title、一个是private的float类型的属性listPrice，之后是封装这两个属性的四个方法，用快捷键Alt+Shift+S选择gennerate Getters and Setters,再实验报告的内容与格式按任课教师的要求书写。

然后就是重写父类的toString（）方法，用快捷键Alt+Shift+S选择gennerate toString，快捷重写。

这段程序写完是这样的：接下来便是BookManagement类，在包book下新建一个类BookManagement，写完的程序是这样的：BookManagement类中创建了书的对象，在主方法中调用output函数，赋值，输出。

041440516 董迎顺实验三 Java程序设计实验报告面向对象技术

长春大学计算机学院网络工程专业Java程序设计实验报告备注：基本技能、进阶技能为必做项目，创新技能为选作项目。

实验名称：实验三面向对象技术班级：网络五班姓名：董迎顺学号：041440516 实验地点：综C601 日期：2016-5-12一、实验目的：1．进一步掌握面向对象程序设计的方法。

2．理解接口和包的概念、接口的定义、类型、继承、组合以及多态。

3．理解类的成员及其访问权限。

二、基本技能实验内容、要求和环境：1．类的继承性新类可从现有的类中产生，并保留现有类的成员变量和方法并可根据需要对它们加以修改。

新类还可添加新的变量和方法。

这种现象就称为类的继承。

当建立一个新类时，不必写出全部成员变量和成员方法。

只要简单地声明这个类是从一个已定义的类继承下来的，就可以引用被继承类的全部成员。

被继承的类称为父类或超类（superclass），这个新类称为子类。

Java 提供了一个庞大的类库让开发人员继承和使用。

设计这些类是出于公用的目的，因此，很少有某个类恰恰满足你的需要。

你必须设计自己的能处理实际问题的类，如果你设计的这个类仅仅实现了继承，则和父类毫无两样。

所以，通常要对子类进行扩展，即添加新的属性和方法。

这使得子类要比父类大，但更具特殊性，代表着一组更具体的对象。

继承的意义就在于此。

（1）创建将被继承的类Java5_1程序源代码如下。

public class Java5_1{protected String xm; //具有保护修饰符的成员变量protected int xh;void setdata(String m,int h) //设置数据的方法{xm =m;xh = h;}public void print() //输出数据的方法{System.out.println(xm+", "+xh);}}编译源程序后得到要继承的父类。

（2）创建继承于父类Java5_1的子类Java5_2，其不仅具有父类的成员变量xm（姓名）、xh（学号），还定义了新成员变量xy（学院）、xi（系）。

面向对象高级实验报告

我的养生经■黄显耀作为20世纪70年代出生的那代人，童年生活虽远不及如今小朋友丰富多彩，但“70后”善于自找乐趣。

记得当年的小伙伴们努力发挥想象力，充分发扬自己动手的作风，传承并创新了可称之为那个年代的中国好游戏——打陀螺、滚铁环、跳皮筋……我之所以将打陀螺列在首位，这是因为我非常喜欢打陀螺，从童年一直打到现在。

对它的喜爱程度，由此可见一斑。

有人爱说抽陀螺，我可不愿意苟同，甚至有些反对，在我的心目中，打陀螺比抽陀螺雅致得多。

闲言少叙，转入正题。

陀螺在《新华字典》上的解释为：一种儿童玩具，呈圆锥形……其实，打陀螺这项运动老少皆宜。

打陀螺的场地没有什么特别的要求，只要地面平整即可。

你一手拿着陀螺，一手拿着系有细绳的木棍子，接着将绳子缠绕在陀螺身上，缠绕的圈数要恰到好处，缠多了不利于拉动陀螺，而缠少了拉动的力量又不够。

缠绕细绳是打陀螺的关键一步，但也没什么技术含量可言，熟能生巧而已。

被拉动的陀螺欢快地飞舞着，你便可以拿着木棍用适当的力度，在任何方向，打陀螺。

此刻，你也许心神飘忽，翩翩欲仙吧。

其实，打陀螺还可以有很多花样呢，比如，左手打3下，右手又接着打3下，并按着3的倍数继续打下去。

另外，一边打陀螺，一边唱歌或背英语单词也是不错的选择。

这不仅锻炼了身体，还起到了灵活头脑的作用，真可谓：一举多得，妙不可言！当然，更妙的是一个人可以同时掌控多个滚动的陀螺。

那种成就感，只有当你亲手打多个陀螺的时候，才能真切地体会到。

也许有人会问你：阁下，想同时掌控多少个陀螺呢？我想，你一定会如韩信一般自信地回答道：多多益善。

日子长了，打陀螺便可以达到炉火纯青的地步，蒙着眼打陀螺也不在话下。

打陀螺可以独个儿玩，也可以多人玩。

一个人玩是锻炼，多人玩就可以竞赛，总之其乐无穷也！记得20世纪80年代中期，我还在市肉联厂子弟学校读小学，那时候与我同班的小伙伴们几乎人手一个陀螺。

冬季课间10分钟，打陀螺不可或缺。

稍稍运动后，身体便迅速暖和起来。

java面向对象设计_高级

17
异常处理：手动抛出
18
异常处理：自定义异常类
问题：在异常类中有众多子类明确表示各个特定的异常，显然不能用这些子类代表 “业务逻辑的异常”，难道我们每次只能使用Exception类手动抛出“业务逻辑的异常”嘛？回答：显然不是，既然异常子类也是继承Exception类，那我们也可以自定义类，使其继承Exception类。
43
集合：Vector的子类Stack类
Stack类模拟了“栈”数据结构——“后进先出”，其提供了如下几个方法：
44
集合
Queue接口模拟了队列的数据结构，队列通常是指“先进先出”的容器，其有一个实现类为：LinkedList LinkedList类也实现了List接口，可以根据索引来随机访问集合中的元素，另外，还实现了Deque接口（代表双向队列）因此LinkedList集合不仅提供List的功能，还额外提供双向队列、栈的功能。 •ArrayList、Vector内部以数组的形式来保存集合中的元素，因此随机访问集合元素上有较好的性能 •LinkedList内部以链表的形式来保存集合中的元素，因此随机访问集合元素时性能较差，但在插入、删除元素时性能非常出色
34
集合：HashSet类
35
集合：TreeSet类
TreeSet是SortedSet接口的唯一实现，TreeSet可以确保集合元素处于排序状态。与HashSet集合相比，TreeSet还提供如下额外方法：
36
集合：TreeSet类
37
集合：TreeSet类
TreeSet会调用集合元素的compareTo(Object obj)方法比较元素之间的大小关系。当一个对象调用该方法与另一个对象进行比较时，例如 pareTo(obj2)，如果该方法返回0，则表明这两个对象相等；如果该方法返回一个正整数，则表明obj1大于obj2；如果该方法返回一个负整数，则表明obj1小于obj2。 Java的一些常用类已经实现了Comparable接口，并提供了比较大小的标准，如下： •BigDecimal、BigInteger以及所有数值型对应包装类 •Character、Boolean、String •Date、Time

Java程序设计Java面向对象高级

《Java程序设计案例教程（）》模块6 面向对象高级学习目的∙掌握抽象类地定义与使用。

（道德规范）掌握接口地定义与实现。

（创新意识）∙掌握异常地概念以及异常地处理方式。

（工匠精神）1抽象类目录CONTENTS 2接口*案例6-1USB接口地实现*案例6-2组装一台计算机3异常处理*案例6-3异常成绩处理当一个类包含抽象方法,该类需要定义为抽象类。

抽象类用abstract 关键字来修饰,示例如下:abstractclassPet{abstractvoideat();}当定义一个类时,常常需要定义一些方法来描述该类地行为特征,但有时这些方法地实现方式是无法确定地。

针对这样地情况,Java 允许在定义方法时不写方法体。

不包含方法体地方法为抽象方法,抽象方法需要使用abstract 关键字来修饰,示例如下:abstractvoideat();注意:包含抽象方法地类需要声明为抽象类,但抽象类可以不包含任何抽象方法。

另外,抽象类是不可以被实例化地。

因为抽象类有可能包含抽象方法,而抽象方法是没有方法体地,不可以被调用。

如果想调用抽象类定义地方法,则需要创建一个抽象类地子类,在子类对抽象类地抽象方法进行实现。

例6-1实现抽象类地抽象方法。

}狗吃骨头");}}}}1抽象类目录CONTENTS 2接口*案例6-1USB接口地实现*案例6-2组装一台计算机3异常处理*案例6-3异常成绩处理6.2.1接口地概念接口是从多个相似类抽象出来地规范,它不提供任何方法地具体实现过程。

接口体现地是规范与实现分离地设计思想。

接口只定义了应当遵循地规范,并不关心这些规范地内部数据与其功能地实现细节,从而分离了规范与实现,增强了系统地可拓展性与可维护性。

因此,接口定义地是多个类同地行为规范,这些行为是与外部交流地通道,这就意味着接口里通常定义地是一组公用方法。

Android操作系统统一充电接口规范在定义接口时,需要使用interface关键字来声明,语法格式如下:[public]interface接口名[extends接口1,接口2,…]{[public][static][final]数据类型常量名=常量值;[public][static][abstract]返回值抽象方法名(参数列表);}Java把接口当作一种特殊地类,每个接口都被编译为一个独立地字节码文件。

java实训心得体会(3篇)

java实训心得体会经过一段时间的java实训，我深刻体会到了实训的重要性和价值。

在这个过程中，我不仅学习到了很多java的知识和技能，还提升了自己的团队合作能力和解决问题的能力。

下面就是我在实训中的一些心得体会。

首先，实训对于我来说是一个宝贵的机会，让我有机会将在课堂上学到的理论知识运用到实践中。

通过实际的项目开发过程，我更加深入地理解了java的各种概念和原理，并掌握了许多实际应用的技巧。

同时，实训也锻炼了我的编程能力和解决问题的能力。

在遇到难题时，我学会了主动寻求帮助和与团队成员合作，最终解决了问题。

其次，实训让我认识到团队合作的重要性。

一个成功的项目离不开团队成员之间的良好合作。

在实训中，我与团队成员共同讨论问题，分工合作，共同完成了一个个子模块的开发。

通过与团队成员的交流和合作，我学到了如何与人合作，如何互相理解和尊重，以及如何充分发挥个人的优势，为团队作出贡献。

除了团队合作，时间管理也是实训中的一项重要技能。

在实训中，我需要根据项目的时间要求和进度安排自己的学习和开发工作。

我学会了如何合理安排时间，如何高效利用时间，以便更好地完成任务。

同时，实训也让我认识到了时间的宝贵，激发了我对待任务的责任感和紧迫感。

在实训中，我还学到了如何处理项目中的bug和异常。

通过调试和排查代码，我逐渐掌握了一些常见bug的解决方法和调试技巧。

同时，我也学到了如何捕获和处理异常，以保证程序的稳定性和可靠性。

这些都是在实际项目中非常实用的技能，对我今后的代码开发和维护都会有很大的帮助。

此外，实训还让我认识到了团队协作的重要性。

在实训中，我需要与不同职能的团队成员进行沟通和协调，合理分配工作，确保项目的顺利进行。

通过与产品经理、设计师和测试团队的协作，我学会了如何进行需求分析和设计，以及如何与测试人员合作进行测试和修复bug。

这些经验不仅提升了我的项目管理能力，也拓宽了我的视野和思维方式。

实训的过程中也不可避免地会遇到一些困难和挑战。

第章Java语言面向对象高级程序设计-资料

4.1 消息通信（Communication With Messages）
4.1.1 消息的类型 1．公有消息与私有消息
公有消息指由外界对象直接发送给某对象的消息；私有消息指对象自己发送给本身的消息，私有消息
对外不开放，外界也不必了解它。外界对象只能向某对象发送公有消息，而不能发送
CSDN Java程序设计 2019/8/17
第04章 Java语言面向对象高级程序设计 • 9 •
教学导航目的要求重点难点内容导航教学小结课后习题上机实验
4.2.1 类的访问控制
表4-1 类的访问控制符及可见性
可见性类控制符访问域
[内网] http://10.1.2.45:8000/java [外网] :8000/java
CSDN Java程序设计 2019/8/17
第04章 Java语言面向对象高级程序设计 • 4 •
教学导航目的要求重点难点内容导航教学小结课后习题上机实验
第04章 Java语言面向对象高级程序设计
4.1 消息通信（Communication With Messages） 4.1.1 消息的类型 4.1.2 消息的使用
4.2 访问控制 4.2.1 类的访问控制 4.2.2 类成员的访问控制
4.3 继承 4.3.1 创建子类 4.3.2 继承的传递性 4.3.3 子类对象的初始化 4.3.4 子类继承父类的规则 4.3.5 上转型与下转型对象 4.3.6 继承的使用方法 4.3.7 继承与组合区别
CSDN Java程序设计 2019/8/17
第04章 Java语言面向对象高级程序设计
教学导航目的要求重点难点内容导航教学小结课后习题上机实验

Java语言编程-面向对象高级

Java语言编程王宁东软培训（沈阳）准备•常量•抽象•接口•多继承final关键字•在Java中final关键字可以被用来修饰类、方法和变量•用final修饰类时表示此类不可以被继承•用final修饰方法是表示此方法不可以被继承类覆盖•用final修饰变量是表示该变量是一个常量，在初始化后不能被改变final关键字•使用final关键字修饰类的static变量，须在定义时或者在静态块中进行初始化•如果修饰实例变量，则可以在动态块中，或者在每个构造方法中进行初始化•可以声明final方法变量现实中的抽象•现实世界中经常存在某些抽象的概念，这些概念是从具体的概念中抽象出来的，因此，通常并不存在与这些概念相对应的实际事物•例如：抽象概念：水果具体概念：苹果、橘子、葡萄……抽象概念：形状具体概念：矩形、圆形、三角形……抽象类与抽象方法•Java语言中使用抽象类来表示前面所指的抽象概念•要定义一个抽象类只需在定义是加上abstract关键字，例如：abstract class Fruit{}抽象类•不能创建抽象类的对象：Fruit f = new Fruit();//错误，不能创建抽象类的对象•抽象类通常是作为一系列普通类的超类来使用：class Apple extends Fruit{}Fruit f = new Apple();现实的抽象行为•抽象概念中经常存在这样一些操作，这些操作适用于所有属于该抽象概念的具体概念；但是，对于在这些具体概念中，对这个有着不同的实现方法，例如：水果“吃”荔枝剥了皮吃桃吐了核吃橘子剥了皮吐了核吃抽象方法•Java语言使用抽象方法来表示这些抽象的操作•在方法声明前使用abstract关键字就可以将方法声明为抽象方法abstract class Fruit{abstract void eat();}抽象类与抽象方法•抽象方法只有声明，不能为抽象方法提供实现：abstract void eat(){//……}•如果一个类中有抽象方法，那么这个类必须被声明为抽象的(abstract)类与其它修饰符的关系•abstract final class•abstract final 修饰方法•static abstract不允许¾因为抽象方法的调用需要使用方法的动态绑定机制，因此静态方法不能是抽象方法•private abstract不允许¾因为抽象方法必须要被继承类重置，因此继承类必须能够访问抽象方法，所以抽象方法的访问权限不能是private抽象类与抽象方法•从抽象的超类继承的类，通常必须实现超类中所有的抽象方法，否则继承类也必须声明为抽象的abstract class Fruit{abstract void eat();}//因为没实现eat，所以必须为abstractabstract class Apple extends Fruit{}//因为实现了eat，所以可以不是abstractclass RedApple extends Apple{void eat(){}}多重继承•多重继承是指一个类从多个类继承而来，即一个类拥有多个超类•Java语言不允许进行多重继承•多重继承带来的麻烦：¾成员变量的访问二义性¾方法绑定的二义性¾对象内存布局问题¾超类引用继承类对象时产生的问题接口定义与实现•定义一个接口：public interface MyInterface{void method1();int method2();}•实现一个接口的方法class MyClass implements MyInterface{ public void method1(){}public int method2(){}}接口的说明•接口可以被看作是：没有实例数据，并且所有方法都是抽象方法的抽象类•接口中的所有方法都是public方法，不能使用其他的访问控制符•接口中的所有方法都是抽象方法，不能使用final关键字说明•接口中不能有静态方法•即使不使用任何关键字说明，接口中的所有数据成员都是public static final接口实现的说明•因为接口中的方法都是abstract，实现一个接口的类必须实现接口中的全部方法，否则该类就必须声明为abstract•因为接口中的所有方法都是public方法，所以实现一个接口中的方法时必须将访问控制符声明为public接口之间的继承•接口之间也可以继承，而且一个接口可以从多个接口继承public DerivedInterfaceextends MyInterface1, MyInterface2{String newMethod();}接口与多重继承•一个类可以实现多个不同的接口：class MyClassimplements MyInterface1, MyInterface2{……}•Java语言中，可以利用接口部分实现对多重继承的支持•避免了多重继承的危险P7-25公有接口•描述和定义要实现的功能•用户与供应商API（实现接口）的纽带•java.sql.Connection•java.sql.Statement•java.jms.Connection•java.servlet.servletRequest•java.servlet.RequestDispathcer接口与多态•可以定义接口的引用来指向实现了接口的类的一个对象，动态绑定有效：MyInterface m1 = new MyClass();MyInterface m2 = new Derived();接口的使用•抽象行为，避免过度继承•多态•模拟多重继承•显示编程接口，隐藏实际细节•建立系统间的合作契约小结•final关键字•抽象类•抽象方法•接口的声明和实现•接口的用途•接口的使用嵌套类•嵌套类：定义在其他类中或方法中的类•嵌套类的功能通常与包含它的类的功能有紧密的关联•内部类的存取控制方式与同他在同一位置上的成员是相同的嵌套类的分类静态嵌套类(Static inner class)•成员内部类(Member inner class)•局部内部类(Local inner class)•匿名内部类(Anonymous inner class)静态嵌套类的定义•定义静态嵌套类的方法类似于声明类的一个静态成员：public class Enclosing{private static int staticMember= 0;public static class StaticInner{public void innerMethod(){System.out.println(staticMember);}}}静态嵌套类的创建与引用•声明静态嵌套类的引用：Enclosing.StaticInner innerRef;•创建静态嵌套类的对象：innerRef= new Enclosing.StaticInner();静态嵌套类的说明•静态内部类不能与它的Enclosing Class同名•静态内部类是类的成员，因此静态内部类可以直接访问Enclosing Class中的所有静态成员；但是，在EnclosingClass中不能直接访问静态嵌套类的成员•作为类的静态成员，不能在静态内部类中直接访问Enclosing Class的非静态成员成员内部类的定义•定义成员内部类的方法类似于定义一个类的普通成员：public class Enclosing{public int member;public class MemberInner{public void innerMethod(){System.out.println(member);}}}成员内部类创建与引用•声明成员内部类的引用：Enclosing.MemberInner innerRef;•创建成员内部类的对象：Enclosing enclosing = new Enclosing();innerRef= enclosing.new MemberInner();或简写为：innerRef=new Enclosing().new MemberInner();成员内部类的说明•成员内部类不能与它的Enclosing Class同名，而且成员内部类中不能定义静态的成员变量或方法•成员内部类可以访问Enclosing Class中的所有成员，不论静态成员还是非静态成员；而Enclosing Class中不能直接访问成员内部类的成员•在成员内部类的方法中this是内部类当前对象的引用，如果需要访问当前的外部类对象需要使用Enclosing.this本地内部类的定义•本地内部类是定义在方法中的内部类：public class Enclosing{int menber= 10;public void containInnerClass(){class LocalInner{public void print(){System.out.println(member);}}}}本地内部类的创建与引用•同方法中定义的变量一样，本地内部类只能在定义它的方法中使用，而且不能使用public,private等访问限定符public void containInner(){class LocalInner{public void print(){}}LocalInner innerRef= new LocalInner();}//…..//LocalInner antherRef;错误无法访问本地内部类的说明•本地内部类不能与它的Enclosing Class同名，而且成员内部类中不能定义静态的成员变量或方法•本地内部类可以访问Enclosing Class中的所有成员，不论静态成员还是非静态成员；而Enclosing Class中不能直接访问本地内部类的成员本地内部类•同成员内部类一样，在本地内部类的方法中this是内部类当前对象的引用，如果需要访问当前的外部类对象需要使用Enclosing.this•本地内部类可以访问包含它的方法中的变量或方法的参数，但是这些变量或参数必须定义为final，内部类中不能改变它们匿名内部类的说明•匿名内部类是没有名字的内部类，它在建立对象的时候完成对类的定义，而不需要给类起名字。