java类和对象数组传参_java面向对象初始与值传递

面向对象的程序设计有三个主要特征，如下:

封装性 继承性 多态性

首先先创建一个简单的类和对象

public classclas {public static voidmain(String[] args) {//首先想要调用类中的信息要先是实例化一个对象类操作

Person p1= newPerson();//然后通过对象给类中的信息赋值

p1.name = "隔壁老王";

p1.age= 17;

p1.talk();//我是隔壁老王今年：17

}

}classPerson{ //类

String name; //属性intage;booleanisMarried;public voidwalk(){ // 方法

System.out.println("人走路");

}public voideat(){

System.out.println("人能吃");

}voidtalk(){

System.out.println("我是"+name+"今年："+age);

}

}

类中的方法是通过void来进行实现的。和python的def差不多

创建对象语法: 类名 对象名 = new 类名();

创建类中的方法一般需要加上void ： void 方法名(){方法体}

注意：在整个java项目(java文件)中不可以出现相同的类，因为java在编译的时候上面的类编译之后 再识别出相同的就会报错，或者在倒入的时候也会导致识别出错

一个类可以有多个对象，实例化的对象的空间每一个都在内存中单独开辟一块空间互不干扰

如果类中有私有属性 private装饰的就不能直接调用或者赋值了不然就会报错

成员变量存储在堆中 是需要垃圾回收机制来处理，局部变量存储在栈中随着方法的结束而释放

练习：

编写教师类和学生类，并通过测试类创建对象进行测试

Student类

属性:

name:String age:intmajor:String interests:String

方法:say() 返回学生的个人信息

Teacher类

属性:

name:String age:int teachAge:intcourse:String

方法:say() 输出教师的个人信息

eg：

public classcls {public static voidmain(String[] args) {

teacher te= newteacher();

te.name= "王老师";

te.age= 17;

stu st= newstu();

st.name= "小明";

st.age= 16;

te.say(st.name,st.age);

st.say(te.name, te.age);

}

}class teacher{ //老师类

String name;intage;

String major;

String interests;void say(String name, intage){

System.out.println("这个学生是："+name+"年龄是："+age);

}

}class stu{ //学生类

String name;intage;intteacherAge;

String course;void say(String name, intage){

System.out.println("这个老师是："+name+"年龄是："+age);

}

}

View Code

方法的声明：

权限修饰符 返回值类型 方法名(形参列表){

方法体

}

方法名：属于标识符，遵循标识符的规则和规范，“见名知意”

注意：我们再传递参数的时候也一定要把参数的类型传递进去不然会报错public void addAge(int age){ //传递参数把参数age的类型int也传递进去

age +=2;

}

return ：java中的return和python的return是一样的。都是返回结果 然后终止方法

方法可以分为void不带返回值的方法 和携带返回值的方法

classte{

String name;//成员变量

intage;

String major;void sys(){ //void不需要返回值

intage;

}publicString getName(){return name; //因为方法体是没有void的就需要return来进行返回了

}

}

注意：

在方法中可以调用方法：递归调用

但是不可以在方法中定义方法

练习：

1、

编写程序，声明一个method方法，在方法中打印一个10*8 的*型矩形，在main方法中调用该方法

public classUsertest {public static voidmain(String[] args) {

Usertest user= newUsertest();

user.method();

}public voidmethod(){for(int i = 0; i < 10; i++){for(int j = 0; j < 8; j++){

System.out.print("*");

}

System.out.println();

}

}

}

View Code

2、

修改上一个程序，在method方法中，除打印一个10*8的*型矩形外，再计算该矩形的面积，* 并将其作为方法返回值。在main方法中调用该方法，接收返回的面积值并打印。

public classUsertest {public static voidmain(String[] args) {

Usertest user= newUsertest();int aray =user.method();

System.out.println("矩形的面积是："+aray);

}public intmethod(){for(int i = 0; i < 10; i++){for(int j = 0; j < 8; j++){

System.out.print("*");

}

System.out.println();

}return 10*8; //想要返回值就要把上面的方法定义为要放回值的类型

}

}

View Code

3、

修改上一个程序，在method方法提供m和n两个参数，方法中打印一个m*n的*型矩形，* 并计算该矩形的面积， 将其作为方法返回值。在main方法中调用该方法，接收返回的面积值并打印。

public classUsertest {public static voidmain(String[] args) {

Usertest user= newUsertest();int aray = user.method(10,5); //给参数

System.out.println("矩形的面积是："+aray);

}public int method(int m, int n){ //传递参数

for(int i = 0; i < m; i++){for(int j = 0; j < n; j++){

System.out.print("*");

}

System.out.println();

}return 10*8; //想要返回值就要把上面的方法定义为要放回值的类型

}

}

View Code

对象数组题目

对象数组题目: 定义类Student，包含三个属性:学号number(int)，年级state(int)，成绩 score(int)。 创建20个学生对象，学号为1到20，年级和成绩都由随机数确定。

问题一:打印出3年级(state值为3)的学生信息。

问题二:使用冒泡排序按学生成绩排序，并遍历所有学生信息

提示:1) 生成随机数:Math.random()，返回值类型double;2) 四舍五入取整:Math.round(doubled)，返回值类型long。5.声明一个日期类型MyDate:有属性:年year,月month，日day。创建2个日期 对象，分别赋值为:你的出生日期，你对象的出生日期，并显示信息。

第一种：

public classUsertest{public static voidmain(String[] args) {

Stude [] stu= new Stude [20]; //生成一个对象数组规定长度为20 因为要生成20个不能一个一个生成吧

for(int i = 0; i < stu.length; i++){

stu[i]= new Stude (); //生成每一个对象的数组//给每一个对象属性赋值

stu[i].number = (i+1);//年纪[1, 6]

stu[i].state = (int)(Math.random()*(6-1+1)+1);

stu[i].score= (int)(Math.random()*(100-0-1)+1);

}//遍历学生数组

for(int i = 0; i < stu.length; i++){//System.out.println(stu[i].number+","+stu[i].state+","+stu[i].score);

System.out.println(stu[i].info());

}

System.out.println();//求出三年级学生的的学生信息

System.out.println("这是三年级学生的信息");for(int i = 0; i < stu.length; i++){if(stu[i].state == 3){

System.out.println(stu[i].info());

}

}

System.out.println("=========");//使用冒泡排序对学生的成绩排序

for(int i = 0; i < stu.length;i++){for(int j = 0; j < stu.length -i -1; j++){if(stu[j].score > stu[j+1].score){ //两个值的转换必须要定义一个第三方数字不能像python一直直接交换

Stude tmp = stu[j]; //参数的定义也要是对象数组的元素

stu[j] = stu[j+1];

stu[j+1] =stu[j];

}

}

}for(int i = 0; i < stu.length; i++){//System.out.println(stu[i].number+","+stu[i].state+","+stu[i].score);

System.out.println(stu[i].info());

}

}static class Stude{ //因为主类是static的 如果写在了公类里面 也要是static，除非是放在公类外部

int number = 0; //学号

int state = 0; //年纪

int score = 0; //成绩

String info(){return "学号："+number+" 年纪: "+state+" 成绩: "+score;

}

}

}

View Code

第二种面向对象的额封装：

public classUsertestplus {public static voidmain(String[] args) {

Student [] stu= new Student[20];for(int i = 0; i < stu.length; i++){

stu[i]= new Student(); //实例化每一个对象//为每一个对象的信息进行赋值

stu[i].number = i+1;

stu[i].state= (int)(Math.random()*(6-1+1)+1);

stu[i].score= (int)(Math.random()*(100 -0 +1)+1);

}//因为方法是在公共类中的 需要公共类的对象来调用

Usertestplus user = newUsertestplus();

user.print(stu);//打印3年纪的学生的信息

System.out.println("打印3年纪学生的信息");

user.searchState(stu,3);//使用冒泡排序来进行信息排序

System.out.println("使用冒泡进行排序");

user.sort(stu);//对排序后的 信息进行遍历

user.print(stu);

}//遍历信息

static void print(Student[] stu){ //把定义的类数组给传递进来

for(int i = 0; i < stu.length; i++){

System.out.println(stu[i].info());

}

}//查找 3年纪的学生的信息

static void searchState(Student [] stu, intstate){for(int i = 0 ;i < stu.length; i++){if(stu[i].state ==state){

System.out.println(stu[i].info());

}

}

}//排序

static voidsort(Student [] stu){for(int i = 0; i stu[j+1].score){

Student tmp=stu[j];

stu[j]= stu[j+1];

stu[j+1] =tmp;

}

}

}

}

}classStudent{int number; //学号

int state; //年纪

int score; //成绩

publicString info(){return "学号："+number+" 年纪："+state+" 成绩："+score;

}

}

View Code

对象的内存解析：

匿名对象：

即没有对这个对象赋名。每一次使用都要new一个

Person p1 = newPerson();//然后通过对象给类中的信息赋值

p1.name = "隔壁老王";

p1.age= 17;

p1.talk();//我是隔壁老王今年：17//上面是创建了有名对象每次使用都通过这个对象名去调用//匿名对象：

new Person().age=16; //通过匿名对象去调用

new Person().name = "老李";//这两个匿名对象是不同的

每一次创建的匿名对象是不同的：

public classclas {public static voidmain(String[] args) {//首先想要调用类中的信息要先是实例化一个对象类操作

Person p1= newPerson();//然后通过对象给类中的信息赋值

p1.name = "隔壁老王";

p1.age= 17;

p1.talk();//我是隔壁老王今年：17//上面是创建了有名对象每次使用都通过这个对象名去调用//匿名对象：

new Person().age=16; //通过匿名对象去调用

new Person().name = "老李";//这两个匿名对象是不同的

new Person().talk(); //我是null今年：0 这里的值是都不同的 所以对象都是不同的

}

}classPerson{

String name;intage;booleanisMarried;public voidwalk(){

System.out.println("人走路");

}public voideat(){

System.out.println("人能吃");

}voidtalk(){

System.out.println("我是"+name+"今年："+age);

}

}

方法的重载：即一个类中可以出现多个名字相同的方法 只要参数的个数或者类型不同即可，甚至两个参数的位置不同的 时候也会认为是两个不同的方法

String name;intage;booleanisMarried;public voidwalk(){

System.out.println("人走路");

}public voideat(){

System.out.println("人能吃");

}//如下的两个方法构成了方法的重载

voidtalk(){

System.out.println("我是"+name+"今年："+age);

}void talk(intage){

System.out.println(age);

}

}

判断是否是重载：

跟方法的权限修饰符、返回值类型、行参变量名、方法体都没有关系

习题：判断是否是重载

与void show(int a,char b,double c){}构成重载的有:

a) void show(int x,char y,double z){} //no

b) int show(int a,double c,char b){} //yes

c) void show(int a,double c,char b){} //yes

d) boolean show(int c,char b){} //yes

e) void show(double c){} //yes

f) double show(int x,char y,double z){} //no

g) void shows(){double c}//no

练习：

编写程序，定义三个重载方法并调用。方法名为mOL。 三个方法分别接收一个int参数、两个int参数、一个字符串参数。分别

执行平方运算并输出结果，相乘并输出结果，输出字符串信息。 在主类的main ()方法中分别用参数区别调用三个方法。3.定义三个重载方法max()，第一个方法求两个int值中的最大值，第二个方 法求两个double值中的最大值，第三个方法求三个double值中的最大值， 并分别调用三个方法

public classclas {public static voidmain(String[] args) {//首先想要调用类中的信息要先是实例化一个对象类操作

Person p1= newPerson();//然后通过对象给类中的信息赋值

p1.name = "隔壁老王";

p1.age= 17;

p1.talk();//我是隔壁老王今年：17//上面是创建了有名对象每次使用都通过这个对象名去调用//匿名对象：

new Person().age=16; //通过匿名对象去调用

new Person().name = "老李";//这两个匿名对象是不同的

new Person().talk(); //我是null今年：0 这里的值是都不同的 所以对象都是不同的//

System.out.println(p1.mOl(3)); //9

System.out.println(p1.mOl(3,6)); //18

System.out.println(p1.mOl("lao")); //这个是：lao

System.out.println(p1.max(3,7)); //7

System.out.println(p1.max(3.2,5.64)); //5。64

}

}classPerson{

String name;intage;booleanisMarried;public voidwalk(){

System.out.println("人走路");

}public voideat(){

System.out.println("人能吃");

}//如下的两个方法构成了方法的重载

voidtalk(){

System.out.println("我是"+name+"今年："+age);

}void talk(intage){

System.out.println(age);

}int mOl(intnum){return num*num;

}int mOl(int num, intnumber){return num*number;

}

String mOl(String str){return "这个是："+str;

}int max(int num, intnumber){int max = (num > number)?num :number;returnmax;

}double max(double num, doublenumber){double max =(num > number)?num :number;returnmax;

}

}

View Code

可变形参：

可变行参的格式：　　数据类型....变量名

oublic vold nick(String .... name){ //可以给nick这个方法传递无限多个的字符串类型的参数

}

当调用可变个数行参的方法时，传入的参数可以是0个1个或者多个

变量的赋值：

如果变量是基本数据类型，此时赋值的变量是变量所保存的数据值

如果变量是引用数据类型，此时赋值的是变量所保存的数据的地址值

如果参数是基本数据类型，此时实参赋值给形参的是实参的真实的数据值

参数的赋予的时候地址的转换：

两个参数的值的赋予：普通数据类型在赋值的时候是只有一个栈空间的。把值在copy一份给另一个参数的。引用数据类型的值的赋予时候是堆空间都指向同一个 只有栈空间的名字不同，所以当一个改变的时候会带动堆空间的值的改变那就是都改变了

引用数据类型赋值

基础数据和引用数据在值的交换的注意

public classswap {public static voidmain(String[] args) {

swap sw= new swap(); //创造公共类对象

swp s = newswp();

s.m=19;

s.n=6;

s.swap(s.m,s.n);

System.out.println("m: "+s.m+"n:"+s.n); //m :19 , n:6 大家思考下为什么没有换成呢？ 因为 你这个m的值和下面的方法中的值是两个了 因为此时的m和n是基础数据类型在栈中有不同的位置 方法中换了

但是最初定义的没有换

sw.swap(s);//因为方法定义在公共类中只能通过公共类来调用

System.out.println("m: "+s.m+"n:"+s.n); //m: 6n:19 因为引用数据类型的值指向的都是一样的所以可以交换成功

}public void swap(swp s){ //使用引用数据类型来当行参

int tmp =s.m;

s.m=s.n;

s.n=tmp;

}

}classswp{intm;intn;public void swap(int m, intn){int tmp =m;

m=n;

n=tmp;

}

}

行参是方法定义时，声明在小括号内的参数

实参：方法调用时，实际传递给行参的数据

例题

public classAprilThreeAfternoonTestOne {public static voidmain(String[] args) {

AprilThreeAfternoonTestOne aprilThreeAfternoonTestOne= newAprilThreeAfternoonTestOne();

aprilThreeAfternoonTestOne.first();

}public voidfirst(){int i = 5;

AprilThreeAfternoon aprilThreeAfternoon= newAprilThreeAfternoon();

aprilThreeAfternoon.i= 25;

second(aprilThreeAfternoon,i);

System.out.println(aprilThreeAfternoon.i);

}public void second(AprilThreeAfternoon aprilThreeAfternoon, inti){

i= 0;

aprilThreeAfternoon.i= 20;

AprilThreeAfternoon af= newAprilThreeAfternoon();

aprilThreeAfternoon=af;

System.out.println(aprilThreeAfternoon.i +" "+i );

}

}classAprilThreeAfternoon{int i = 15;

}

求出结果

15 0

20

20 是因为在second结束之后就释放了所覆盖的所以又回到了以前所赋值的

结果

面试题：

定义一个int型的数组:int[] arr = new int[]{12,3,3,34,56,77,432}; 让数组的每个位置上的值去除以首位置的元素，得到的结果，作为该位置上的 新值。遍历新的数组

答案：

//错误写法

for(int i= 0;i < arr.length;i++){ 因为这样就会把除去的数字当作第一位数字了

arr[i]= arr[i] / arr[0]; }//正确写法1

for(int i = arr.length – 1;i >= 0;i--){

arr[i]= arr[i] / arr[0]; }//正确写法2

int temp = arr[0];for(int i= 0;i < arr.length;i++){

arr[i]= arr[i] / temp; }

计算1-100直接所有自然数的和：

public static voidmain(String[] args) {

jia ji= newjia();

System.out.println(ji.sum(100));

}public int sum(intnum){if(num == 1){return 1;

}else{return num+sum(num-1);

}

}

}

View Code