① java：如何封装集合
对于一般的成员变量，对其提供简单的getter/setter封装即可。而对于一个集合类，不能够这样做。 对于一个简单的成员变量，可以这样：
class Athlete {
private String name;
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
// ......
而如果是一个Set/List/Map或数组，应该：
[1]初始化这个集合类；
[2]提供对单个元素的add/remove；
[3]提供加入另一个集合的方法。如果是基于此初始化，则先保证当前集合无元素；
[4]对于getter方法，应该返回该集合的只读试图；
[5]提供当前集合size。
public class Game {
private Set<Athlete> players = new HashSet<Athlete>();// 1
public void addPlayer(Athlete one) {// 2
players.add(one);
}
public void removePlayer(Athlete one) {// 2
players.remove(one);
}
public void addPlayers(Set<Athlete> set) {// 3
Iterator<Athlete> iter = set.iterator();
while (iter.hasNext())
addPlayer(iter.next());
}
public void initializaPlayers(Set<Athlete> set) {// 3
if (getAttendNumbers() > 0)
players.clear();
players.addAll(set);
}
public Set<Athlete> getAllPlayers() {// 4
return Collections.unmodifiableSet(players);
}
public int getAttendNumbers() {// 5
return players.size();
}
② java 封装是什么
什么是封装？
在定义类的时候，如果可以直接修改类中的字段那么就可能会出现以下的情况，age可以设置成1000，score可以设置为10000
所以就引出了封装的概念，那么什么是封装呢或者说封装可以实现那些目的
封装可以隐藏实现的细节
让使用者只能通过实现写好的访问方法来访问这些字段，这样一来我们只需要在这些方法中增加逻辑控制，限制对数据的不合理访问、
方便数据检查，有利于于保护对象信息的完整性
便于修改，提高代码的可维护性
为了实现良好的封装，需要从两个方面考虑
把字段（成员变量）和实现细节隐藏起来，不允许外部直接访问
把方法暴露出来，让方法控制这些成员变量进行安全的访问和操作
因此，封装就有两个含义：把该隐藏的隐藏起来，把该暴露的暴露出来。
③ 在JAVA中如何封装代码
封装在java中有两种表现
1.用类封装一个事物的属性和方法。
2.用方法来封装一个固定的算法。
楼上所说的其实是封装的程度不一样，在面向对象的术语中粒度来表示这个程度。
封装其实是要看情况而定的，如果你这个类是描述人的，需要这个人完成一些基本的动作，如吃饭，走路，那么就不用把细胞也封装进来。但是如果“人”这个类，需要做医学的研究用，那么就需要封装细胞这个属性了。
代码打多了就自然能理解了，不是一个复杂的概念。呵呵。
④ 类怎样实现封装的
1.基本类型只能按值传递，而每个基本类型对应的封装类是按引用传递的。
2.从性能上说java中的基本类型是在堆栈上创建的，而所有的对象类型都是在堆上创建的，（对象的引用在堆栈上创建）。比如
Integer i=new Integer(10); 其中new Integer()是在堆上创建的，而他的引用Integer i是在堆栈上。 封装类的出现，是为了更方便的使用一些基本类型不具备的方法，比如valueOf（），toString（）等等。还有你如果想传递一个int对象的引用，而不是值，那只能用封装类。
在堆栈上分配内存的调用效率和在堆上分配内存的效率差太多了。虽然在堆栈上分配内存效率高，不过在堆栈上分配内存有内存泄露的问题。（这是一个平庸程序员基本解决不了的问题...）java用了一种很天才的方法提高了在堆上分配内存的效率，尽管如此，java还是慢。他不太可能达到向c++那么快，尽管他一直在承诺总有一天虚拟机会和机器码速度一样快。
⑤ java如何封装静态类到一个方法里
可以这样写。
public class FileUtil {
private static FileUtil m_uttil = null;
public static FileUtil example() {
if (null == m_uttil) {
m_uttil = new FileUtil();
}
return m_uttil;
}
public void getFile() {
System.out.println("xx");
}
public static void main(String args[]) {
FileUtil.example().getFile();
}
}
请采纳，谢谢
⑥ JAVA中什么是封装类，如何使用
java中的封装类是基本类型的封装成对象。
使用方法：
package wrapper;
public class IntegerTest1 {
public static void main(String[] args)
{
Integer i=new Integer(123);
byte b=i.byteValue();
double d=i.doubleValue();
System.out.println("将Integer封装类转换为 byte值为："+b);
System.out.println("将Integer封装类转换为 double值为："+d);
String s1=Integer.toBinaryString(i);
String s2=Integer.toOctalString(i);
String s3=Integer.toHexString(i);
System.out.println("转换为二进制的值为:"+s1);
System.out.println("转换为八进制的值为:"+s2);
System.out.println("转换为十六进制的值为:"+s3);
}
}
⑦ 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时有用的常量和方法。
⑧ 请问如何把一段java程序封装成类
将变量声明成私有的（private），再提供一个或多个公有的（public）方法实现对该变量的访问或修改，这样就达到了封装的目的。
如下面的程序：
public class A {
private String name ;
private int age;
public void setName(String u_name){
this.name = u_name;
}
public String getName(){
return this.name;
}
public void setAge(int u_age){
this.age = u_age;
}
public int getAge(){
return this.age;
}
}
⑨ java中如何把一个函数封装成一个类
有一个函数：a
void a(){}
封装到类B：
class B{
void a(){}
}
这样就好了，
使用：
B haha=new B();
haha.a();//调用类B的实例haha中的a方法