一、对象作为参数的方法参数传递，类作为返回值类型的方法：
package test;
public class TestCar {
public static void main(String[] args) {
Car c1=new Car();
c1.setName("马萨拉蒂");
c1.setWheel(4);
c1.info();
c1.show();
c1.setName("火车");
c1.setWheel(99);
c1.info();
Factory f=new Factory();
Car c2=f.produceCar();
f.describeCar(c2);
Car c3=f.produceCar("奥拓",4);
f.describeCar(c3);
}
}
class Factory{
//制造车（两个重载方法）
public Car produceCar() {
return new Car();
}
public Car produceCar(String n,int w) {
Car c=new Car();
c.name=n;
c.wheel=w;
return c;
}
public void describeCar(Car c) {
c.info()
}
}
class Car{
//1、属性
String name;
int wheel;
//2、方法
public void info() {
// show();
System.out.println("name:"+name+"wheel:"+wheel);
}
public void show() {
System.out.println("我是一辆车");
}
public String getName() {
return name;
}
public void setName(String n) {
name=n;
}
public void setWheel(int w) {
wheel=w;
}
}二、题目要求如下
/*
* (1)、定义一个Circle类,包含一个double类型的radius属性代表圆的半径;
* 一个findArea()方法返回圆的面积。
* (2)、定义一个类PassObject,在类中定义一个方法printArea(),该方法定义如下:
* public void printArea(Circle c,int time)
* 在printArea方法中打印输出1到time之间的每个整数半径值,以及对应的面积。
* 例如:
* time为5,则输出半径1、2、3、4、5,以及对应的面积。
* 在main方法中调用printArea()方法,调用完毕后输出当前半径值。
* */
package day03;
public class PassObject {
public void printArea(Circle c,int time) {
System.out.println("Radius:"+"\t\t"+"Area");
// int temp=0;
// for(int i=1;i<=time;i++,temp=i) {
// c.setRadius(i);
// System.out.println(c.getRadius()+"\t\t"+c.findArea());
// }
// c.setRadius(temp);
int i=1;
while(i<=time) {
c.setRadius(i);
System.out.println(c.getRadius()+"\t\t"+c.findArea());
i++;
}
c.setRadius(i);
}
public static void main(String[] args) {
PassObject p=new PassObject();
Circle c=new Circle();
p.printArea(c, 5);
System.out.println("now radius is"+c.getRadius());
}
}
class Circle{
double radius;
public double findArea() {
return Math.PI*radius*radius;
}
public void setRadius(double r) {
radius=r;
}
public double getRadius() {
return radius;
}
}三、匿名类对象(new Circle())：创建的类的对象是匿名的。
（1）、当我们只需要一次调用类的对象时，我们就可以考虑使用匿名的方式创建类的对象。
（2）、特点：创建的匿名类的对象只能调用一次。
匿名类直接用：new Circle(); new Circle().show();等等。
匿名类只能用一次，匿名类不像其他类有栈空间存地址指向堆空间村的对象，而匿名类无栈空间存放地址。所以只能一次调用(new Circle().什么什么)，只能在创建的时候调用一次，如果想再调用必须有名，但是却没名。
New Circle.show(); //可以
New Circle.setRadius(3.2);
New Circel.show(); //第二次调用不可以
Circle c=new Circle(); //Circle类型的变量(对象)；
四、含有可变个参数的方法实例(题目要求如下)：
package test;
/*
*
* 1、可变个数的形参的函数声明：Public void sayHello(String … args){ …… }
（1）、格式：对于方法的参数：数据类型 … 形参名；
（2）、可变个数的形参的方法与同名的方法之间构成重载；
（3）、可变个数的形参在调用时，个数从0开始，到无穷多个都可以；
（4）、使用可变多个形参的方法与方法的形参使用数组是一致的（表达意思相同）；
（5）、如果一个类中的方法中有可变多个形参的话，一定将可变多个形参声明在其他参数最后；
（6）、在一个方法中最多声明一个可变个数的形参
*
* */
public class TestArgs {
public static void main(String[] args) {
TestArgs t=new TestArgs();
t.sayHello();
t.sayHello(new String[] {"hello china","hello beijing"});
}
//如下四个方法构成重载
//刚开始两个(添加注释的两个方法)可以省略,因为后两个是可变个数形参可以包含前两个。
// public void sayHello() {
// System.out.println("hello world!");
// }
// public void sayHello(String str1) {
// System.out.println("hello "+str1);
// }
//可变个数的形参方法
public void sayHello(String ...args) {
for(int i=0;i<args.length;i++) {
System.out.println(args[i]+"$");
}
}
public void sayHello(int i,String...args) {
System.out.println(i);
for(int j=0;j<args.length;i++) {
System.out.println(args[j]+"%");
}
}
public void sayHello1(String[] args) {
for(int i=0;i<args.length;i++) {
System.out.println(args[i]);
}
}
public int getSum(int...args) { //计算n项数字的总和。
int sum=0;
for(int i=0;i<args.length;i++) {
sum+=args[i];
}
return sum;
}
}可以在一个类中定义方法(实现功能),在类中的main函数中如果想调用方法实现功能,必须在类的main函数中用类名先实例化一个对象。方法将功能封装起来便于调用。
五、参数传递机制
1、
树 栈
package test;
/*
* 方法的参数传递
* (1)、形参:方法声明时,小括号内的参数
* 实参:调用方法时,实际传入的参数
* (2)、guize:Java中的参数传递 & 值传递
* 1)形参时基本数据类型的--将实参的值传递给形参的基本数据类型的变量
* 2)形参时引用数据类型的—-将实参的引用类型变量的值(对应的堆空间的对象实体的首地址值)传递给形参的引用。
* */
public class TestArgsTransfer {
public static void main(String[] args) {
int i=10;
int j=5;
System.out.println("i:"+i+",j:"+j);
//交换两个变量的值
// int temp=i;
// i=j;
// j=temp;
System.out.println("交换后swap函数中:");
TestArgsTransfer t=new TestArgsTransfer();
t.swap(i, j);
System.out.println("交换后main函数中:\ni="+i+",j="+j);
}
public void swap(int i,int j) {
int temp=i;
i=j;
j=temp;
System.out.println("i:"+i+",j:"+j);
}
}有一个类中main函数与自定义的交换函数中位置的方法同等级,在main方法中调用交换函数也要先实例化一个类对象,即:类名 实体名=new 类名();
2、
package test;
public class TestArgsTransfer1 {
public static void main(String[] args) {
TestArgsTransfer1 tt=new TestArgsTransfer1();
DataSwap ds=new DataSwap();
System.out.println("ds.i:"+ds.i+",ds.j:"+ds.j);
tt.swap(ds);
System.out.println("交换后:\nds.i:"+ds.i+",ds.j:"+ds.j);
}
//交换变量的值
public void swap(DataSwap d) {
int temp=d.i;
d.i=d.j;
d.j=temp;
}
}
class DataSwap{
int i=10;
int j=5;
}
3、方法的值传递机制的练习。
package day03;
class Value{
int i=15;
}
public class TestValue {
public static void main(String[] args) {
TestValue t=new TestValue();
t.first();
}
public void first() {
int i=5;
Value v=new Value();
v.i=25;
second(v,i);
System.out.println(v.i);
}
public void second(Value v,int i) {
i=0;
v.i=20;
Value val=new Value();
v=val;
System.out.println(v.i+""+i);
}
}
290
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
