java四种封装测试代码,java类的封装实验报告

java 三角形、梯形和圆形的类封装

你稍等一下，我把代码测试通过后。给你贴出来

您有以下几处错误：

1，Trangle书写错误 Trangle

public Trangle(double a,double b,double c) ===》public Trangele(double a,double b,double c)

（错误）public Trangle(double a,double b,double c)

{

sideA=a;sideB=b;sideC=c;

if(a+bca+cbb+ca)

{

boo=true;

}

2，siedB书写错误

double p=(sideA+siedB+sideC)/2.0; ===double p=(sideA+sideB+sideC)/2.0;

（错误）public double getArea()

{if(boo)

{

double p=(sideA+siedB+sideC)/2.0;

area=Math.sqrt(p*(p-sideA)*(p-sideB)*(p-sideC));

return area;

总结：

在你整个的错误当中主要是Trangle 雷明不统一造成的，已经书写马虎。siedB

你需要理解有参构造方法，需要和类名相同。已经void没有返回值，double 类型需要有返回值，而且return 的位置。以下是经测试正确运行的代码：

类一：

package shiyan1;

public class Trangle {

double sideA,sideB,sideC,area,length;

boolean boo;

public Trangle(double a,double b,double c)

{

sideA=a;sideB=b;sideC=c;

if(a+bca+cbb+ca)

{

boo=true;

}

}

public double getArea(){

if(boo){

double p=(sideA+sideB+sideC)/2.0;

area=Math.sqrt(p*(p-sideA)*(p-sideB)*(p-sideC));

}

return area;

}

public void setABC(double a,double b,double c){

sideA=a;sideB=b;sideC=c;

if(a+bca+cbb+ca)

{

boo=true;

}

}

}

类二：

public class AreaAndLength

{

public void main(String args[])

{

double length,area;

Circle circle=null;

Trangle trangle;

Lader lader;

circle=new Circle(10);

trangle=new Trangle(3,4,5);

lader=new Lader(3,4,10);

length=circle.getLength();

}

}

2. 编写一个完整的类用来说明Java中的封装，并编写另一个类进行测试 这个怎么做，求大

public class Student {

private int number;

private String name;

private String courseName;

private int score;

public int getNumber() {

return number;

}

public void setNumber(int number) {

this.number = number;

}

public String getName() {

return name;

}

public void setName(String name) {

this.name = name;

}

public String getCourseName() {

return courseName;

}

public void setCourseName(String courseName) {

this.courseName = courseName;

}

public int getScore() {

return score;

}

public void setScore(int score) {

this.score = score;

}

@Override

public String toString() {

return "Student [number=" + number + ", name=" + name + ", courseName="

+ courseName + ", score=" + score + "]";

}

}

//封装是把过程和数据包围起来，对数据的访问只能通过已定义的接口。面向对象计算始于这个基本概念，即现实世界可以被描绘成一系列完全自治、封装的对象，这些对象通过一个受保护的接口访问其他对象。封装是一种信息隐藏技术，在java中通过关键字private实现封装。什么是封装？封装把对象的所有组成部分组合在一起，封装定义程序如何引用对象的数据，封装实际上使用方法将类的数据隐藏起来，控制用户对类的修改和访问数据的程度。

student类的那些属性就是数据了，get和set方法就是已定义的接口，任何一个个student对象的实例，要操作其属性都只能通过get和set方法；

public class Test {

public static void main(String[] args) {

Student s = new Student();

s.setName("张三");

s.setCourseName("化学");

s.setNumber(1);

s.setScore(90);

// s.name = "张三";//错误的

System.out.println(s);

}

}

Java语言中的封装有哪些?

JAVA中常用的封装方式有以下几种：

1 、Boolean VS boolean

public final class Boolean extends Object  implementsSerializable,Comparable

Boolean 类将基本类型为boolean的值包装在一个对象中。一个Boolean类型的对象只包含一个类型为boolean的字段。此外，此类还为boolean和String的相互转换提供了许多方法，并提供了处理 boolean时非常有用的其他一些常量和方法。

2、 Byte VS byte

public final class Byte extends Number implements Comparable

Byte类将基本类型 byte的值包装在一个对象中。一个Byte类型的对象只包含一个类型为 byte的字段。此外，该类还为 byte和 String的相互转换提供了几种方法，并提供了处理 byte时非常有用的其他一些常量和方法。

3、 Character VS char

public final class Character extends Object  implements Serializable, Comparable Character类在对象中包装一个基本类型char的值。       Character类型的对象包含类型为char的单个字段。此外，该类提供了几种方法，以确定字符的类别（小写字母，数字，等等），并将字符从大写转换成小写，反之亦然。

4 、Double VS double

public final class Double extends Number implements Comparable Double类在对象中包装了一个基本类型double的值。每个Double类型的对象都包含一个double类型的字段。此外，该类还提供了多个方法，可以将double转换为String，将String转换为double，还提供了其他一些处理double时有用的常量和方法。

5、 Float VS float

public final class Float extends Number implements Comparable  

Float类在对象中包装了一个float基本类型的值。Float类型的对象包含一个float类型的字段。此外，此类提供了几种方法，可在float类型和String类型之间互相转换，并且还提供了处理float类型时非常有用的其他一些常量和方法。

关于java的封装

这个是为了以后编程提供一个接口，你这个程序不写上去也是对的，但是谁能保证你以后不会用到这个函数呢。

java 请通过代码封装，实现如下需求： 编写一个类Book，代表教材:

public class Book {

private String book_id;//教材编号

private String book_grade;//教材所属年级

private String book_name;//教材名字

private Double book_price;//教材价格

public String getBook_id() {

return book_id;

}

public void setBook_id(String book_id) {

this.book_id = book_id;

}

public String getBook_grade() {

return book_grade;

}

public void setBook_grade(String book_grade) {

this.book_grade = book_grade;

}

public String getBook_name() {

return book_name;

}

public void setBook_name(String book_name) {

this.book_name = book_name;

}

public Double getBook_price() {

return book_price;

}

public void setBook_price(Double book_price) {

this.book_price = book_price;

}

public Book(String book_id, String book_grade, String book_name, Double book_price) {

super();

this.book_id = book_id;

this.book_grade = book_grade;

this.book_name = book_name;

this.book_price = book_price;

}

public Book() {

super();

}

@Override

public String toString() {

return "Book [book_id=" + book_id + ", book_grade=" + book_grade + ", book_name=" + book_name

+ ", book_price=" + book_price + "]";

}

}

在JAVA中如何封装代码?

封装在java中有两种表现

1.用类封装一个事物的属性和方法。

2.用方法来封装一个固定的算法。

楼上所说的其实是封装的程度不一样，在面向对象的术语中粒度来表示这个程度。

封装其实是要看情况而定的，如果你这个类是描述人的，需要这个人完成一些基本的动作，如吃饭，走路，那么就不用把细胞也封装进来。但是如果“人”这个类，需要做医学的研究用，那么就需要封装细胞这个属性了。

代码打多了就自然能理解了，不是一个复杂的概念。呵呵。