创建一个对象
package Day3.d0;
/**
* 定义一个类
* 创建多个对象默认人的各种行为
*/
public class d0 {
// 静态特征 成员变量 名称 field
String name;
int age;
// 动态行为 成员方法 动词 method
public void eat(){
System.out.println("人是铁饭是钢一顿不吃饿得慌");
}
public void work(){
System.out.println("好好学习天天向上");
}
public void rest(String site){
System.out.println(name+"在"+site+"休息");
}
}
package Day3.d0;
public class Testd0 {
public static void main(String[] args) {
d0 k1 = new d0();
k1.name = "张三";
k1.age = 23;
k1.eat();
k1.work();
k1.rest("工地");
}
}
结果
人是铁饭是钢一顿不吃饿得慌
好好学习天天向上
张三在工地休息
成员变量有默认值,可以不赋值
此时内存中发生了什么
构造方法极其重载
1、构造方法
我们每次new,都是一个构造方法
package com.xjy;
public class Computer {
private String brand;//品牌
private double size;//尺寸
public Computer(){
System.out.println("这里是构造方法,也叫构造器,和类同名不写返回值,完成创建对象的初始化操作");
System.out.println("如果一个构造方法也没有写,那么默认有一个无参数的构造方法");
}
public Computer(String brand,double size){
this.brand=brand;
this.size=size;
// this只能加到成员变量上
}
public void show(){
System.out.println(size+"寸的"+brand);
}
public int add(int num1,int num2){//num1和num2是局部变量
return num1+num2;
}
public int sub(int num1,int num2){
return num1-num2;
}
public static void main(String[] args) {
/* Computer computer = new Computer();//这里的new Computer()就是构造方法
computer.brand="lianxiang";
computer.size=4.5;//但是这里一个个赋值很麻烦 我们可以再构造的时候直接将方法传过去*/
Computer computer = new Computer("lianxiang",4.5);//但是这里就需要写一个带参数的构造方法
computer.show();//4.5寸的lianxiang
}
}
2、对象数组
package com.xjy;
public class ObjectArray {
public static void main(String[] args) {
//基本数据类型的数组
int[] arr;
arr = new int[4];
arr[0]=0;
arr[1]=1;
arr[2]=2;
arr[3]=3;
for (int x:arr) {
System.out.print(x+",");
}
System.out.println();
//引用类型的数组
Computer[] arr2=new Computer[4];
arr2[0]=new Computer("yinter",4.4);
arr2[1]=new Computer("aierlan",10.2);
arr2[2]=new Computer("jinshidun",2.4);
arr2[3]=new Computer("ccdisd",8.9);
for (Computer x:arr2) {
x.show();
/* 4.4寸的yinter
10.2寸的aierlan
2.4寸的jinshidun
8.9寸的ccdisd*/
}
}
}
此时的电脑内存图:
引用类型默认值为null
3、关于值传递
4、关于引用传递
第一回合
package com.xjy;
public class Change {
public static void main(String[] args) {
P p = new P();
p.x=10;
p.y=20;
System.out.println("交换前"+"x="+p.x+",y="+ p.y);
swap(p.x, p.y);
System.out.println("交换后"+"x="+p.x+",y="+ p.y);
}
/**
* 交换两个值
*/
public static void swap(int num1,int num2){
int temp;
temp=num1;
num1=num2;
num2=temp;
}
}
结果:
交换前x=10,y=20
交换后x=10,y=20
可见,此时的值并没有成功交换,因为它传入的p.x是一个确定的值,而不是地址,所以是复制了一份传给了swap的形参
第二回合
package com.xjy;
public class Change {
public static void main(String[] args) {
P p = new P();
p.x=10;
p.y=20;
System.out.println("交换前"+"x="+p.x+",y="+ p.y);
swap(p);
System.out.println("交换后"+"x="+p.x+",y="+ p.y);
}
/**
* 交换两个值
*/
public static void swap(P p){
int temp;
temp=p.x;
p.x=p.y;
p.y=temp;
}
}
结果:
交换前x=10,y=20
交换后x=20,y=10
经过改良,传入的是p对象,是一个引用类型,传入的是地址,所以在本质上也改变了。
注意此时swap的形参是P p
this关键字
①每创建一个对象就会产生一个this,this只能访问成员变量不能访问局部变量
②还可以在构造函数的时候减少代码量,且只能放在第一条语句
package com.xjy;
public class P {
int x;
int y;
int z;
public P(){
}
public P(int x,int y){
this.x=x;
this.y=y;
}
public P(int x,int y,int z){
this(x,y);
this.z=z;
}
}
③调用成员方法 this.show(),当然this在这里可以省略