java中Methode如何返回两个值-->利用数组

题目要求是返回最大最小值
int [] a = {19,25,34,78,10,56};
//for(int k = 0;k<mxnmax(a).length;k++){
//System.out.println(mxnmax(a)[k]);
//System.out.println(mxnmax(a).length);
//};
mxnmax(a);
}


   public static int [] mxnmax(int[] a){
    int min = a[0];
    int max = a[0];
    for(int i =0;i<a.length;i++){
    if(a[i]>=max){
    max = a[i];
    }
    if(a[i]<=min){
    min = a[i];
    }
    }
    System.out.println("min = " + min);
        System.out.println("max = " + max);
        int[]arr = new int[2];
        arr[0] = min;
        arr[1] = max;
    return arr;
    }

}

java数组中如何去掉最后一个元素并且数组缩小

public class deletelast {
public static void main(String args[]){
char[] arry ={'a','b','c','d','w','6','1'};
   System.out.println(a(arry));
   System.out.println(a(arry).length);
}
static char[] a(char[]arry){

char[]arry1 = new char[arry.length-1];
for(int i = 0;i<arry.length-1;i++){
arry1[i]=arry[i];
}

return arry1;
}
 
}

Java主方法的理解

主方法是静态的，要直接在主方法中调用其他方法，则该方法必须是静态的。
主方法是没有返回值的。
主方法是形参为数组。

关键字static 的理解

Es können Attribute und Methode definiert werden,deren Nutzung nicht an die Existenz von Objekten gebunden ist.

上面说的这种情况就是用statische Variable 和statische Methode.

Es existiert nur ein Exemplar dieser Varialben,unabhängig von der Anzahl der Instanzn der Klasse,und Ihre Lebensdauer erstreckt sich über das ganze Programm.
和static有关的变量和方法之和class有关。

public class StaticTest{
       static double PI=3.1415;
       static int id;
       public static void method1(){
       //方法体
       }
       public void methode2(){
       System.out.println(StaticTest.PI);
       System.out.println(StaticTest.id);
       StaticTest.method1();
       }
}

用类名.变量名或者类名.方法名调取
静态数据和静态方法的中用通常是为了提供共享数据或者方法。如数学计算公式。数据常量。

它是属于整个类的。不是属于某个对象的。
没有对象也可以访问，用类名.变量名

public class cat{
       private static int sid = 0;
       private String name;
       int id;
       cat(String name){
           this.name = name;
           id = sid++;
       }
       public void info(){
           System.out.println("my name is" + name + "No." + id)
       }

      public static void main(String args[]){
             cat.sid = 100；//可以直接在主方法里，给sid赋值，不需要通过对象。
             cat mimi = new cat("mimi");
             cat pipi = new cat ("pipi");
             mimi.Info();
             pipi.Info();
}


}

Java中的super 和 this 的理解

在Java中，this通常指当前对象，super则指父类的。当你想要引用当前对象的某种东西，比如当前对象的某个方法，或当前对象的某个成员，你便可以利用this来实现这个目的，当然，this的另一个用途是调用当前对象的另一个构造函数，如果你想引用父类的某种东西，则非super莫属。this与super有如此相似的一些特性和与生俱来的某种关系。this 关键字只能在方法内部使用，表示对“调用方法的那个对象的引用”
“”
This:在一般方法中 
最普遍的情况就是，在你的方法中的某个形参名与当前对象的某个成员有相同的名字，这时为了不至于混淆，你便需要明确使用this关键字来指明你要使用某个成员，使用方法是“this.成员名”，而不带this的那个便是形参。另外，还可以用“this.方法名”来引用当前对象的某个方法，但这时this就不是必须的了，你可以直接用方法名来访问那个方法，编译器会知道你要调用的是那一个。

public class DemoThis{

private String name;

private int age;

DemoThis(String name,int age){

setName(name);//你可以加上this来调用方法，像这样：this.setName(name);但这并不是必须的 

setAge(age);

this.print();//这里就是用this;PS:在构造函数里不仅可以有传递对象的参数，还可调取方法

}

public void setName(String name){

this.name = name;}

public voide setAge(int age){

this.name = age;

}

public void pirnt(){

System.out.println("Name=" +name+"ge="+ age);

}

}

下面演示super的用法

class Person{ 
public int c; 
private String name; 
private int age; 
protected void setName(String name){ 
this.name=name; 
} 
protected void setAge(int age){ 
this.age=age; 
} 
protected void print(){ 
System.out.println("Name="+name+" Age="+age); 
} 
} 
public class DemoSuper extends Person{ 
public void print(){ 
System.out.println("DemoSuper:"); 
super.print(); 
} 
public static void main(String[] args){ 
DemoSuper ds=new DemoSuper(); 
ds.setName("kevin"); 
ds.setAge(22); 
ds.print(); 
} 
} 在DemoSuper中，重新定义的print方法覆写了父类的print方法，它首先做一些自己的事情，然后调用父类的那个被覆写了的方法。输出结果说明了这一点： 

DemoSuper: 
Name=kevin Age=22

在构造函数中构造函数是一种特殊的方法，在对象初始化的时候自动调用。在构造函数中，this和super也有上面说的种种使用方式，并且它还有特殊的地方，请看下面的例子：

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38

class Person {     public static void  prt(String s) {         System.out.println(s);     }     Person() {         prt("A Person.");     }     Person(String name) {         prt("A person name is:" + name);     } } public class Chinese extends Person {     Chinese() {         super(); // 调用父类构造函数（1）         prt("A chinese.");// (4)     }     Chinese(String name) {         super(name);// 调用父类具有相同形参的构造函数（2）         prt("his name is:" + name);     }     Chinese(String name, int age) {         this(name);// 调用当前具有相同形参的构造函数（3）         prt("his age is:" + age);     }     public static void main(String[] args) {         Chinese cn = new Chinese();         cn = new Chinese("kevin");         cn = new Chinese("kevin", 22);     } } 在这段程序中，this和super不再是像以前那样用“.”连接一个方法或成员，而是直接在其后跟  上适当的参数，因此它的意义也就有了变化。super后加参数的是用来调用父类中具有相同形式的  构造函数，如1和2处。this后加参数则调用的是当前具有相同参数的构造函数，如3处。当然，在  Chinese的各个重载构造函数中，this和super在一般方法中的各种用法也仍可使用，比如4处，你  可以将它替换为“this.prt”(因为它继承了父类中的那个方法）或者是“super.prt”（因为它  是父类中的方法且可被子类访问），它照样可以正确运行。但这样似乎就有点画蛇添足的味道  了。