1、类是模板,对象是具体的实例
2、如果成员函数中的局部变量与成员变量名一致,则该方法对这个变量名的访问是局部变量
class lesson1
{
int age=9;
void talk()
{
int age = 2;
System.out.println("my age is "+age);
}
public static void main(String [] args)
{
lesson1 test = new lesson1();//()一定要有,这样它才通过调用系统默认的构造函数
test.talk();
}
}
/*
F:\java_example>java lesson1
my age is 2
*/
3、生成对象时,内存的分配
lesson1 test = new lesson1();
等号左边以类名lesson1作为变量类型定义了一个test变量,来指向等号右边通过new关键字创建的一个lesson1类的实例对象,变量test就是对象的引用句柄,对象的引用句柄是栈中分配的一个变量,对象本身,是在堆中分配的。test的值即为该对象在堆中的首地址。
4、==与equals的区别
lesson1 t1 = new lesson1();
lesson1 t2 = t1;
leeson1 t3 = new lesson1();
t1,t2两个变量指向同一个对象,即t1、t2中存的都是lesson1的首地址,if(t1==t2),则为true
t1,t3两个变量分别指向两个新创建的lesson1对象,尽管创建的两个string实例对象看上去一模一样,但它们是两个彼此独立的对象,是两个占据不同存储空间的不同对象,if(t1.equals(t3)),则为true
t1和t3分别指向了两个新创建的lesson1类对象
class Person
{
int age;
void talk()
{
System.out.println("my age is "+age);
}
public static void main(String [] args)
{
Person p1 = new Person();
Person p2 = new Person();
p1.age = 5;
p1.talk();
p2.talk();
}
}
//如果把main()单独拿出来,不放在类中,会报错“需要class, interface或enum”
/*
F:\java_example>java Person
my age is 5
my age is 0
*/
5、匿名对象
class lesson1
{
int age=9;
void talk()
{
int age = 2;
System.out.println("my age is "+age);
}
public static void main(String [] args)
{
//lesson1 test = new lesson1();//()一定要有,这样它才通过调用系统默认的构造函数
new lesson1().talk();
}
}
/*
F:\java_example>java lesson1
my age is 2
*/
这段代码没有产生任何句柄,而是直接用new关键字创建了一个lesson1的对象,并直接调用它的talk方法,得到的结果和之前是一样的,这个方法执行完,这个对象也就变成了垃圾
使用匿名对象的两种情况:
(1)当一个对象只需要进行一次方法调用时,可以使用匿名对象
(2)将匿名对象作为实参传递给一个函数调用,比如
public static void getsomeone(Person p)
{
......
}
可以使用如下语句来调用这个函数
getsomeone(new Person.())
6、实现类的封装性
在第四点的示例代码中,反映了一个问题,age是Person的一个成员,是它的属性,如果外部的程序能把Person类的属性给修改了,会造成不可预估的错误,就像一个人的年龄,不会因为外部而随意修改。为了限制对象对它属性的修改,我们需要添加private修饰符,来加以限制。但是又要对象能够访问他的属性,那我们就写一个public方法,将它的成员变量的值传递出去。如下图代码所示,我们增加了setAge(),getAge()来实现外部程序对age的赋值和获取,并且还可以统一的对age进行限制。这样我们就实现了对类的封装。
class Person
{
private int age = 23;
public void setAge(int i)
{
if(i<0)
return;
age=i;
}
public int getAge()
{
return age;
}
public void talk()
{
System.out.println("my age is "+age);
}
}
class TestPerson
{
public static void main(String [] args)
{
Person p1 = new Person();
Person p2 = new Person();
p1.setAge(-19);
p2.getAge();
p1.talk();
p2.talk();
}
}
/*
F:\java_example>java TestPerson
my age is 23
my age is 23*/
实现封装的目的:
a 隐藏类的实现细节;
b 让使用者只能通过事先制定好的方法来访问数据,可以方便的加入控制逻辑,限制对属性不合理的操作;
c 便于修改,增强代码的可维护性;(比如,我们要更改成员变量的名字,如果不进行封装,那就要每个使用到它的地方都要进行修改,而封装后,只需要改类中这块地方就好)
d 可进行数据检查。
一个类通常就是一个小的模块,我们应该让模块尽可能只公开需要让外界知道的内容,其他内容尽量隐藏。在设计模块时,需要追求强内聚、弱耦合。
7、构造函数
构造函数的功能主要用于在类的对象创建时定义初始化的状态。
a 构造函数的特征:
b 没有返回值;
c 函数名与类名一致;
不能在方法中用return返回一个值。
构造函数不能被直接调用,必须通过new运算符在创建对象时才会自动调用;而一般的方法是在程序执行到它的时候被调用的。
当一个类只定义了私有的构造函数,将无法通过new关键字来创建其对象.
当程序中没有显式写出构造函数,会有一个默认的构造函数,并且是无参数的;一旦编程者为类定义了构造函数,那么系统就不再提供默认的构造函数
1 class Person
2 {
3 private int age;
4 private String name = "unknown";
5 public void setAge(int i)
6 {
7 if(i<0)
8 return;
9 age=i;
10 }
11 public int getAge()
12 {
13 return age;
14 }
15 public Person()
16 {
17 System.out.println("You are calling me!");
18 }
19 public Person(int a)//构造函数的重载
20 {
21 age=a;
22 }
23 public Person(String n,int a)//构造函数的重载
24 {
25 name=n;
26 age=a;
27 }
28 public void talk()
29 {
30 System.out.println(name+" is "+age);
31 }
32 }
33
34 class TestPerson
35 {
36 public static void main(String [] args)
37 {
38 Person p1 = new Person();
39 Person p2 = new Person(26);
40 Person p3 = new Person("Jane",20);
41 p1.talk();
42 p2.talk();
43 p3.talk();
44 }
45 }
46 /*如果将public Person()注释掉,则会报错
47 F:\java_example>javac lesson2.java
48 lesson2.java:38: 错误: 对于Person(没有参数), 找不到合适的构造器
49 Person p1 = new Person();
50 ^
51 构造器 Person.Person(int)不适用
52 (实际参数列表和形式参数列表长度不同)
53 构造器 Person.Person(String,int)不适用
54 (实际参数列表和形式参数列表长度不同)
55 不注释掉的话则打印如下内容
56 You are calling me!
57 unknown is 0
58 unknown is 26
59 Jane is 20*/