基础阶段测试

1.     配置PATH的作用？

     答：是系统用来指定可执行文件的完整路径。

表达式二：因为在jdk下bin文件夹中有很多我们在开发中要使用的工具，如java.exe,javac.exe,jar.ex等,那么我们在使用时，想要在电脑的任意位置下使用这些java开发工具，那么我们就需有把这些工具所在的路径配置到系统的环境变量中，当我们使用时，系统可以帮助我们找到这些命令。

2.     java的基本数据类型分为四型八种，分别指那些？我们选择数据类型的时候按照那种原则选用？

答：

4型

整型、浮点型、字符型和布尔型

八类

整型（byte、short、int、long）默认类型为int类型，-128 ~ 127

浮点型（float、double）          默认类型为double类型

字符型（char）

布尔型（boolean） 

节省内存空间的原则 

3.     定义一个函数接收一个分数，然后判断并输出录入的分数对应的等级。100-90 A级， 89-80 B级，79-70 C级 以此类推，一直到E级。

packagecom.beiwo;
importjava.util.*;
public classGrade {
    public static void main(String[] args) {
        System.out.println("请输入考试分数：");
        while(true){
              Scanner sc = new Scanner(System.in);      
             double score = sc.nextDouble();       
             char grade;
             if (score >= 90.0)
                 grade = 'A';
             else if (score >= 80.0)
                 grade = 'B';
             else if (score >= 70.0)
                 grade = 'C';
             else if (score >= 60.0)
                 grade = 'D';
             else
                 grade = 'E';
                  System.out.println("你的成绩是:" + grade);             }
    }
}

4. 定义一个程序。计算1-100奇数的总和,要求使用上continue关键字。

public static void main(String[]args) { 
int sum =0; 
for(int i= 1 ; i<=100 ;i++){
if(i %2 == 0)
       continue;
 sum+=i;
} 
System.out.println(sum);
 } 
}

// 2500

5. 定义一个函数接收一个数组对象,找出数组中的最大、最小值相加，把总和返回给调用者。

public class Demo5 {
       public static void main(String[] args) {
       int[] arr = {3,5,2,6,9,1};
       int sum = getSum(arr);
              System.out.println(sum);
       }
public static intgetSum(int[] arr){
       int min = arr[0];
       int max = arr[0];
       for(int i = 0;i < arr.length ;i++){
       //找最大值
       if(max < arr[i]){
       max = arr[i];
}
       //找最小值
       if(min > arr[i]){
       min = arr[i];
       }
}
       return max + min;
       }
}    
//10
6. 自定义一个数组，使用冒泡排序思想对数组的元素进行排序。
答：public class Bubblesort{
       public static void main(String[] args) {
              int[] arr={100,40,60,87,34,11,56,0};
              for(inti=0;i<arr.length-1;i++){
              for(intj=0;j<arr.length-1-i;j++){
              if(arr[j]>arr[j+1]){
              inttemp=arr[j];
              arr[j]=arr[j+1];
              arr[j+1]=temp;
              }
       }
}
       for(inti=0;i<arr.length;i++){
       System.out.print(arr[i]+"\t");
       }
 }
}

7简单的描述面向对象的三大特征。

答：

1.封装给对象提供了隐藏内部特性和行为的能力。对象提供一些能被其他对象访问的方法

来改变它内部的数据。

在 Java 当中，有 3 种修饰符：public，private 和 protected。每一种修饰符给其他的位于同一个包或者不同包下面对象赋予了不同的访问权限。 

2.继承给对象提供了从基类获取字段(是类的话，就是类的成员（包括public,private,protected）)和方法的能力。继承提供了代码的重用行，也可以在不修改类的情况下给现存的类添加新特性。

3.多态是编程语言给不同的底层数据类型做相同的接口展示的一种能力。一个多态类型上

的操作可以应用到其他类型的值上面。

方式二:封装

（1）封装是把过程和数据包围起来，对数据的访问只能通过已定义的界面。面向对象计算始于这个基本概念，即现实世界可以被描绘成一系列完全自治、封装的对象，这些对象通过一个受保护的接口访问其他对象。

继承

（1）继承是一种联结类的层次模型，并且允许和鼓励类的重用，它提供了一种明确表述共性的方法。

（2）对象的一个新类可以从现有的类中派生，这个过程称为类继承，新类继承了原始类的特性，新类称为原始类的派生类（子类），而原始类称为新类的基类（父类）。

（3）派生类可以从它的基类那里继承方法和实例变量，并且类可以修改或增加新的方法使之更适合特殊的需要。

多态性

（1）多态性是指允许不同类的对象对同一消息作出响应。

（2）多态性包括参数化多态性和包含多态性。

（3）多态性语言具有灵活、抽象、行为共享、代码共享的优势，很好的解决了应用程序函数同名问题。 

8. .抽象类和接口的区别

答：1：抽象类只能被继承，而且只能单继承。

接口需要被实现，而且可以多实现。

2：抽象类中可以定义非抽象方法，子类可以直接继承使用。

接口中都是抽象方法，需要子类去实现。

3：抽象类使用的是 is a关系。

接口使用的 like a关系。

4：抽象类的成员修饰符可以自定义。 

区别：

接口中所有的方法隐含的都是抽象的。而抽象类则可以同时包含抽象和非抽象

的方法。

类可以实现很多个接口，但是只能继承一个抽象类。类如果要实现一个接口，它必须要实现接口声明的所有方法。但是，类可以不实现抽象类声明的所有方法，当然，在这种情况下，类也必须得声明成是抽象的。

抽象类可以在不提供接口方法实现的情况下实现接口。

Java 接口中声明的变量默认都是 final 的。抽象类可以包含非 final 的变量。

Java 接口中的成员函数默认是 public 的。抽象类的成员函数可以是 private，

protected 或者是 public。

接口是绝对抽象的，不可以被实例化。抽象类也不可以被实例化，但是，如果

它包含 main 方法的话是可以被调用的。

9.定义一个单利

class Single{
   //1.私有化构造方法
   private Single(){}
   //2.创建一个静态的成员变量接收对象
   static Single s ;
   //3.提供一个初始化对象的方法
   public static Single initSingle(){     
       if(s == null){  
          s = new Single1();
       }
       return s;
    }
}

第一种形式：定义一个类，它的构造函数为private的，它有一个static的private的该类变量，在类初始化时实例化，通过一个public的getInstance方法获取对它的引用,继而调用其中的方法。

public class Singleton {
　　privateSingleton(){}
　　//在自己内部定义自己一个实例。
　　//注意这是private 只供内部调用
　　privatestatic Singleton instance = new Singleton();
　　//这里提供了一个供外部访问本class的静态方法，可以直接访问　　
　　publicstatic Singleton getInstance() {
　　　　returninstance; 　　
　　 }
}
 
　　第二种形式：
public class Singleton {
private staticSingleton instance = null;
public staticsynchronized Singleton getInstance() {
//这个方法比上面有所改进，不用每次都进行生成对象，只是第一次　　　
//使用时生成实例，提高了效率！
if (instance==null)
instance＝new Singleton();
 
              return instance;
       }
}

10.Error与Exception有什么区别？

答：Error ：错误 : 指的是jvm或者硬件的原因导致的错误 ，一般情况下不需要人为的处理。

Execption：异常 :程序员写代码导致的问题，一般需要用代码来处理异常。它是所有异常的父类.

表达式二：

error 表示恢复不是不可能但很困难的情况下的一种严重问题。比如说内存溢出。不

可能指望程序能处理这样的情况。

 exception 表示一种设计或实现问题。也就是说，它表示如果程序运行正常，从不会发生的情况。

11.在java中一个类被声明为final类型，表示了什么意思？

答：表示最终的，是修饰符。

表示该类不能被继承，是顶级类,最终类。

12.java中常量的定义方式

  答：public static final 变量名=值；

13. short s1 = 1; s1 = s1 + 1;有什么错? short s1 = 1; s1 += 1;有什么错?

答： 对于short s1 = 1; s1 =s1 + 1;由于s1+1运算时会自动提升表达式的类型，所以结果是int型，再赋值给short类型s1时，编译器将报告需要强制转换类型的错误。

对于short s1 = 1; s1 +=1;由于 +=是java语言规定的运算符，java编译器会对它进行特殊处理，因此可以正确编译。

方式二：

short s1 = 1; s1 = s1 + 1;有错，s1是short型，s1+1是int型,不能显式转化为short型。

可修改为s1 =(short)(s1 + 1)。short s1 = 1; s1 += 1正确。

14.abstractclass和interface有什么区别?

两者的语法区别：

1.抽象类可以有构造方法，接口中不能有构造方法。

2.抽象类中可以有普通成员变量，接口中没有普通成员变量

3.抽象类中可以包含非抽象的普通方法，接口中的所有方法必须都是抽象的，不能有非抽象

的普通方法。

4.抽象类中的抽象方法的访问类型可以是 public，protected，但接口抽象方法只能是 public 类型的，并且默认即为 public abstract类型。

5.抽象类中可以包含静态方法，接口中不能包含静态方法。

6.抽象类和接口中都可以包含静态成员变量，抽象类中的静态成员变量的访问类型可以任

意，但接口中定义的变量只能是public static final 类型，并且默认即为 public static final 类型。

7.一个类可以实现多个接口，但只能继承一个抽象类。

两者在应用上的区别：

接口更多的是在系统架构设计方法发挥作用，主要用于定义模块之间的通信契约。而抽象类

在代码实现方面发挥作用，可以实现代码的重用。

表达式二：

声明方法的存在而不去实现它的类被叫做抽象类（abstract class），它用于要创建一

个体现某些基本行为的类，并为该类声明方法，但不能在该类中实现该类的情况。不能创建abstract 类的实例。然而可以创建一个变量，其类型是一个抽象类，并让它指向具体子类的一个实例。不能有抽象构造函数或抽象静态方法。Abstract 类的子类为它们父类中的所有抽象方法提供实现，否则它们也是抽象类为。取而代之，在子类中实现该方法。知道其行为的其它类可以在类中实现这些方法。接口（interface）是抽象类的变体。在接口中，所有方法都是抽象的。多继承性可通过实现这样的接口而获得。接口中的所有方法都是抽象的，没有一个有程序体。接口只可以定义static final成员变量。接口的实现与子类相似，除了该实现类不能从接口定义中继承行为。当类实现特殊接口时，它定义（即将程序体给予）所有这种接口的方法。然后，它可以在实现了该接口的类的任何对象上调用接口的方法。由于有抽象类，它允许使用接口名作为引用变量的类型。通常的动态联编将生效。引用可以转换到接口类型或从接口类型转换，instanceof 运算符可以用来决定某对象的类是否实现了接口。

15.try {}里有一个return语句，那么紧跟在这个try后的finally {}里的code会不会被执行，什么时候被执行，在return前还是后

答：会执行，在return前执行。

16.编程题: 用最有效率的方法算出2乘以8等於几?

答：2 << 3，

因为将一个数左移 n 位，就相当于乘以了 2 的 n 次方，那么，一个数乘以 8 只要将其左移 3位即可，而位运算cpu 直接支持的，效率最高，所以，2 乘以 8 等於几的最效率的方法是 2 <<3。 

17 .重写和重载的区别在于

答：

方法重写（Overriding）和方法重载（Overloading）是 Java 多态性的不同表现。重写

Overriding 是父类与子类之间多态性的一种表现，重载 Overloading 是一个类中多态性的一种表现。

如果在子类中定义某方法与其父类有相同的名称和参数，我们说该方法被重(Overriding)。子类的对象使用这个方法时，将调用子类中的定义，对它而言，父类中的定义如同被“屏蔽”了。

如果在同一个类中定义了多个同名的方法，它们或有不同的参数个数或有不同的参数类

型，则称为方法的重载(Overloading)。

Java 中的方法重载发生在同一个类里面两个或者是多个方法的方法名相同但是参数不同的情况。与此相对，方法覆盖是说子类重新定义了父类的方法。方法覆盖必须有相同的方

法名，参数列表和返回类型。覆盖者可能不会限制它所覆盖的方法的访问。 

18.用代码实现一个内部类的访问

class Outer{
int num = 4;
class Inner {
void show(){
System.out.println("innershow run "+num);
}
}
public void method(){
Inner in = new Inner();
in.show();
 
方式二：class Outer{      
        //内部类
        classInner {
            public void print(){
             System.out.println("这个是局部内部类的方法");
            }
        }  
   }
class Demo18{
    public static voidmain(String[] args) {
       Outer.Inner inner= new Outer().new Inner();
       inner.print();
    }
}

19.构造方法和普通方法的区别

       答：

结构上：

        1.构造函数是没有返回值，方法名就是类名。

        2.构造函数是由jvm来调用的，自己是无法手动调用，只会被调用一次。

     作用：

        1.初始化的时候给属性赋值。

        2.描述对象的某种行为。   

20.编题：金额转换，阿拉伯数字的金额转换成中国传统的形式如：

（￥1011）－>（一千零一拾一元整）输出。

public class RBM {
    private static final char[] date=newchar[]{'零','壹','贰','叁','肆','伍','陆','柒','捌','玖'};
    private static final char[] units=newchar[]{'元','拾','佰','仟','万','拾','佰','仟','亿'};
    public static void main(String[] args){
       System.out.println(convert(1011)+"整");
    }
   
    public static String convert(intmoney){
       StringBuilder sb=new StringBuilder();
       int unit = 0;
       while(money !=0){
           sb.append(units[unit++]);
           intnum = money%10;
           sb.append(date[num]);
           money/=10;
       }
       returnsb.reverse().toString().replaceAll("零[拾佰仟]","零").replaceAll("零{4}万","零").replaceAll("零+","零").replaceAll("零万","万").replaceAll("零元","元");
    }
}

表达式二：

1.  package programe;  
2.  import java.text.NumberFormat;  
3.  import java.util.HashMap;  
4.  import java.util.Scanner;  
5.  public class AmountOfConversion {  
6.      //定义HashMap的value值 
7.      public static final String EMPTY = "";  
8.      public static final String ZERO = "零";  
9.      public static final String ONE = "壹";  
10.    public static final String TWO = "贰";  
11.    public static final String THREE = "叁";  
12.    public static final String FOUR = "肆";  
13.    public static final String FIVE = "伍";  
14.    public static final String SIX = "陆";  
15.    public static final String SEVEN = "柒";  
16.    public static final String EIGHT = "捌";  
17.    public static final String NINE = "玖";  
18.    public static final String TEN = "拾";  
19.    public static final String HUNDRED = "佰";  
20.    public static final String THOUSAND = "仟";  
21.    public static final String TEN_THOUSAND = "万";  
22.    public static final String HUNDRED_MILLION = "亿";  
23.    public static final String YUAN = "元";  
24.    public static final String JIAO = "角";  
25.    public static final String FEN = "分";  
26.    public static final String DOT = ".";  
27.    private static AmountOfConversion formatter = null; 

//创建AmountOfConversion的实例对象 
28.     //创建初始化一个HashMap对象 
29.    private HashMap NumberMap = new HashMap();  
30.    private HashMap HighnumberofMoney = new HashMap();  
31.   //创建初始化一个NumberFormat对象 
32.    private NumberFormat numberFormat = 
NumberFormat.getInstance();  
33.    private AmountOfConversion() {   
34.              //在用new创建AmountOfConversion对象时，
为HashMap对象进行key-value的映射 
35.        numberFormat.setMaximumFractionDigits(4); 
//设置数据的小数部分的最大位数是4位 
36.        numberFormat.setMinimumFractionDigits(2); 
//设置数据的小数部分的最小位数是2位 
37.        numberFormat.setGroupingUsed(false);    
/*设置此格式中是不可以使用组。如果设置可以使用组，
则数 1234567 可能被格式化为 "1,234,567"*/ 
38.        NumberMap.put("0", ZERO);  
39.        NumberMap.put("1", ONE);  
40.        NumberMap.put("2", TWO);  
41.        NumberMap.put("3", THREE);  
42.        NumberMap.put("4", FOUR);  
43.        NumberMap.put("5", FIVE);  
44.        NumberMap.put("6", SIX);  
45.        NumberMap.put("7", SEVEN);  
46.        NumberMap.put("8", EIGHT);  
47.        NumberMap.put("9", NINE);  
48.        NumberMap.put(DOT, DOT); 
49.        HighnumberofMoney.put("1", TEN);  
50.        HighnumberofMoney.put("2", HUNDRED);  
51.        HighnumberofMoney.put("3", THOUSAND);  
52.        HighnumberofMoney.put("4", TEN_THOUSAND); 
53.        HighnumberofMoney.put("5", TEN);  
54.        HighnumberofMoney.put("6", HUNDRED);  
55.        HighnumberofMoney.put("7", THOUSAND);  
56.        HighnumberofMoney.put("8", HUNDRED_MILLION); 
57.    }  
58.    public static AmountOfConversion getInstance() { 

//判断AmountOfConversion对象formatter是否初始化 
59.        if (formatter == null)  
60.            formatter = new AmountOfConversion();  
61.        return formatter;  
62.    }  
63.    //进行金额转换的多种数据类型 
64.    public String format(String moneyStr) { 
65.        String result = "不能进行金额转换！！";  
66.        if(isConversion(moneyStr)){  
67.            result = convertIntegerTochinese(moneyStr); 
68.            result = convertPointTochinese(result); 
69.        } 
70.        return result;  
71.    }  
72.    public String format(double moneyDouble) {  
73.        return format(numberFormat.format(moneyDouble)); 
74.    }  
75.    public String format(int moneyInt) {  
76.        return format(numberFormat.format(moneyInt)); 
77.    }  
78.    public String format(long moneyLong) {  
79.        return format(numberFormat.format(moneyLong)); 
80.    }  
81.    public String format(Number moneyNum) { 
82.        return format(numberFormat.format(moneyNum)); 
83.    }  
84.    private String convertIntegerTochinese(String moneyStr) { 

//将参数中传入的阿拉伯数字转换成中文 
85.        String result; 
86.        StringBuffer C2CStrBufer = new StringBuffer();  
87.        for (int i = 0; i < moneyStr.length(); i++) { 
88.            C2CStrBufer.append(NumberMap.get(moneyStr.substring( 
89.                    i, i + 1)));  
90.        } 
91.        // 拾佰仟万亿等都是汉字里面才有的单位，加上它们 
92.        int indexOfDot = C2CStrBufer.indexOf(DOT); 
93.        int moneyPatternCursor = 1;  
94.        for (int i = indexOfDot - 1; i > 0; i--) {  
95.            C2CStrBufer.insert(i, HighnumberofMoney.get(EMPTY 
96.                    + moneyPatternCursor)); 
97.            moneyPatternCursor = moneyPatternCursor == 8 ? 1 
98.                    : moneyPatternCursor + 1;  
99.        } 
100.         String fractionPart = C2CStrBufer.substring(C2CStrBufer 
101.                 .indexOf("."));  
102.         C2CStrBufer.delete(C2CStrBufer.indexOf("."),  
103.                 C2CStrBufer.length()); 
104.         while (C2CStrBufer.indexOf("零拾") != -1) {  
105.             C2CStrBufer.replace(C2CStrBufer.indexOf("零拾"),  
106.                     C2CStrBufer.indexOf("零拾") + 2, ZERO);  
107.         } 
108.         while (C2CStrBufer.indexOf("零佰") != -1) {  
109.             C2CStrBufer.replace(C2CStrBufer.indexOf("零佰"),  
110.                     C2CStrBufer.indexOf("零佰") + 2, ZERO);  
111.         } 
112.         while (C2CStrBufer.indexOf("零仟") != -1) {  
113.             C2CStrBufer.replace(C2CStrBufer.indexOf("零仟"),  
114.                     C2CStrBufer.indexOf("零仟") + 2, ZERO);  
115.         } 
116.         while (C2CStrBufer.indexOf("零万") != -1) {  
117.             C2CStrBufer.replace(C2CStrBufer.indexOf("零万"),  
118.                     C2CStrBufer.indexOf("零万") + 2, TEN_THOUSAND); 
119.         } 
120.         while (C2CStrBufer.indexOf("零亿") != -1) {  
121.             C2CStrBufer.replace(C2CStrBufer.indexOf("零亿"),  
122.                     C2CStrBufer.indexOf("零亿") + 2, HUNDRED_MILLION); 
123.         } 
124.         while (C2CStrBufer.indexOf("零零") != -1) {  
125.             C2CStrBufer.replace(C2CStrBufer.indexOf("零零"),  
126.                     C2CStrBufer.indexOf("零零") + 2, ZERO);  
127.         } 
128.         if (C2CStrBufer.lastIndexOf(ZERO) == C2CStrBufer.length() - 1)  
129.             C2CStrBufer.delete(C2CStrBufer.length() - 1,  
130.                     C2CStrBufer.length()); 
131.         C2CStrBufer.append(fractionPart); 
132.         result = C2CStrBufer.toString(); 
133.         return result;  
134.     } 
135.     private String convertPointTochinese(String moneyStr) {  

//对小数点后面的数字进行汉字处理 
136.         String result; 
137.         StringBuffer C2CStrBufer = new StringBuffer(moneyStr);  
138.         int indexOfDot = C2CStrBufer.indexOf(DOT); 
139.         C2CStrBufer.replace(indexOfDot, indexOfDot + 1, YUAN);  
140.         C2CStrBufer.insert(C2CStrBufer.length() - 1, JIAO);  
141.         C2CStrBufer.insert(C2CStrBufer.length(), FEN); 
142.         if (C2CStrBufer.indexOf("零角零分") != -1)// 没有零头，加整 
143.             C2CStrBufer.replace(C2CStrBufer.indexOf("零角零分"),  
144.                     C2CStrBufer.length(), "整");  
145.         else if (C2CStrBufer.indexOf("零分") != -1)// 没有零分，加整 
146.             C2CStrBufer.replace(C2CStrBufer.indexOf("零分"),  
147.                     C2CStrBufer.length(), "整");  
148.         else {  
149.             if (C2CStrBufer.indexOf("零角") != -1)  
150.                 C2CStrBufer.delete(C2CStrBufer.indexOf("零角"),  
151.                         C2CStrBufer.indexOf("零角") + 2);  
152.         } 
153.         result = C2CStrBufer.toString(); 
154.         return result;  
155.     } 
156.     private boolean isConversion(String moneyStr) {  

//判断参数传来的数据是否符合进行转换的条件 
157.         int fractionDigits = moneyStr.length() - 
moneyStr.indexOf(DOT) - 1;  
158.         boolean flag = true;  
159.         if (fractionDigits > 2){  
160.             System.out.println("金额" + moneyStr + "
的小数位多于两位。");                                  
// 精度不能比分低 
161.             flag = false;  
162.         } 
163.         return flag;  
164.              
165.     } 
166.     public static void main(String args[]) {  
167.         System.out.println("请输入金额数：");  
168.         Scanner scanner = new Scanner(System.in);  
169.         String str = scanner.next(); 
170.         System.out.println("转换后的金额为：");  
171.         System.out.println(getInstance().format(new Double(str)));  
172.     } 
173. } 

附件题目

1.目前有数组” int[] arr =  {11,2, 4, 2, 10, 11}，定义一个函数清除该数组的重复元素，返回的数组不准浪费长度。

public class Demo21 {
       public static void main(String[] args) {
  public static void main(String[] args) {
              int[] arr = {11,2, 4, 2, 10, 11};
       //1.计算重复的个数
       int count = 0 ;  //记录重复的个数
       for(int i= 0; i < arr.length -1;i++){
       for(int j = i+ 1 ; j<arr.length;j++){
       if(arr[i] == arr[j]){
       count++;
       break; // 防止重复计数
              }
       }
}    
       //System.out.println(count);  
 
       //2.创建一个新的数组，将旧的值赋值给新数组。
       int[] newArr = new int[arr.length - count];
 
       int index = 0;
       for(int i = 0;i < arr.length ;i++){   
       //定义一个变量来判断是否是重复的值
       boolean flge = false;     
       //将新数组中的元素和旧数组中的元素做对比，如果俩个值相等部赋值，不等才赋值。
       //11,2, 4, 2, 10, 11
       for(int j = 0 ; j < newArr.length ; j++){
       if(newArr[j] == arr[i]){
       //不赋值
       flge = true;
       break;
       }
}    
 
       if(flge == false){
        //不重复才赋值
       //赋值
       newArr[index++] = arr[i];
       }    
}
 
       for(int a:newArr){
              // 增强for循环
              System.out.println(a);
              }
       }         
}

              int[] arr = {11,2, 4, 2, 10, 11};
       //1.计算重复的个数
       int count = 0 ;  //记录重复的个数
       for(int i= 0; i < arr.length -1;i++){
       for(int j = i+ 1 ; j<arr.length;j++){
       if(arr[i] == arr[j]){
       count++;
       break; // 防止重复计数
              }
       }
}    
       //System.out.println(count);  
 
       //2.创建一个新的数组，将旧的值赋值给新数组。
       int[] newArr = new int[arr.length - count];
 
       int index = 0;
       for(int i = 0;i < arr.length ;i++){   
       //定义一个变量来判断是否是重复的值
       boolean flge = false;     
       //将新数组中的元素和旧数组中的元素做对比，如果俩个值相等部赋值，不等才赋值。
       //11,2, 4, 2, 10, 11
       for(int j = 0 ; j < newArr.length ; j++){
       if(newArr[j] == arr[i]){
       //不赋值
       flge = true;
       break;
       }
}    
 
       if(flge == false){
        //不重复才赋值
       //赋值
       newArr[index++] = arr[i];
       }    
}
 
       for(int a:newArr){
              // 增强for循环
              System.out.println(a);
              }
       }         
}