Java学习之路--构造器
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
/**
* 测试构造器
* @author 葛宇
*/
package 面向对象;

class Point{
double x,y;
//构造方法名称和类名必须保持一致
//构造器会返回对象的地址但是无需指定返回值,可以单独使用return表示结束方法体
public Point(double x,double y) {
this.x = x;
this.y = y;
return;
}

public Point() {
//无参构造器,如果有了自己定义的构造器,系统便不再生成,想要无参构造器的话还得自己写上
}

public double getDitance(Point p) {
System.out.println("传入对象的地址:"+p);
return Math.sqrt((this.x-p.x)*(this.x-p.x)+(this.y-p.y)*(this.y-p.y));
}
}

public class TestConstructor {
public static void main(String[] args) {
Point a = new Point(3.0,4.0);
Point b = new Point(0.0,0.0);
System.out.println("创建的对象的地址:"+b);
System.out.println(a.getDitance(b));
}
}

Java学习之路--参数传递机制
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
/**
* 测试JAVA中的参数传递机制
* @author 葛宇
*/
package 面向对象;

public class TestValueTransport {

int a;
int b;

TestValueTransport (int a,int b){
this.a = a;
this.b = b;
}

void testValueTrap(TestValueTransport x) {
System.out.println(x);
}

public static void main(String[] args) {

TestValueTransport obj = new TestValueTransport(1,2);
TestValueTransport obj_ = obj;

System.out.println(obj);
System.out.println(obj_);
obj_.testValueTrap(obj_);

//输出三个对象变量引用的地址是相同的
//要能区分对象变量和对象的区别:对象变量存储在栈中,对象存储在堆中
//示例中的obj、obj_、x三者虽是不同的对象变量,但是始终指向同一个对象的地址
//总结:Java中参数传值传递的是参数值的副本,但要明确对于对象变量来说,传递的副本就是对象的地址,所以指向还是同一个对象
}
}

Java学习之路--类和对象
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
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
/**
* 测试类和对象
* @author 葛宇
*/
package 面向对象;

//一个文件可以有多个类,但是public修饰的类只能有一个
public class TestFirstClass {
//开始就以学生为对象做示例

//属性
int id;
int age;
String name;
Subjects subject;

//方法
void study() {
System.out.println("学习"+subject.name);
}

void show() {
System.out.println("ID:"+this.id);
System.out.println("AGE:"+this.age);
System.out.println("NAME:"+this.name);
}

TestFirstClass(){
//构造方法,用于创建类对象,方法名与类名保持一致,无返回值,无参构造方法可由系统自动生成
}


//main()方法程序执行的入口,必不可少
public static void main(String[] args) {
TestFirstClass stu = new TestFirstClass(); //调用构造方法在堆区创建对象,返回对象在堆区的地址
Subjects sub = new Subjects(); //调用构造方法在堆区创建对象,返回对象在堆区的地址

//对象属性的赋值
sub.name = "JAVA课设";
//对象属性的赋值
stu.id = 12345;
stu.age = 20;
stu.name = "葛宇";
stu.subject = sub;

stu.study(); //调用类方法
stu.show(); //调用类方法

System.out.println(sub); //打印对象地址
System.out.println(stu.subject); //打印对象地址
//观察发现输出两个对象地址相同,原因是sub放于堆中,44行的赋值实际上是把sub的堆地址赋值给了stu.subject
//分析可知:sub和stu.subject都位于栈区,都指向堆区的同一个对象地址
}
}

//学科科目类
class Subjects{
String name;
}

/* JAVA内存分析
* JAVA中主要把内存分为三部分:栈、堆、方法区(其中堆区包含方法区)
*
* 栈:JVM会为每个线程创建一个栈且栈属于线程私有,无法与其他线程共享;
* 栈的存储特性是“先进后出”;
* 栈是自动分配,内存空间连续,速度快;
* 程序中的每个方法执行时都会在栈中创建一个栈帧,用于存放该方法运行时数据、局部变量、实参、返回值等信息;
*
* 堆:堆区存放创建好的对象和数组(数组也是对象);
* JVM只有一个堆区,且被所有线程共享;
* 堆区是一个不连续的内存空间,分配灵活,速度慢;
*
* 方法区(静态区):方法区也是堆区的一部分,只有一个,被所有线程共享;
* 方法区中存放程序中不变或唯一的内容:类代码、静态变量、常量、字符串等;
*/