我是靠谱客的博主 热情耳机，这篇文章主要介绍12-5Java面向对象笔记（一）1.面向对象的概念：将整个操作进行拆分，采用组装的形式表达。2.类与对象 3.引用传递4.封装性4.构造方法5.匿名对象，现在分享给大家，希望可以做个参考。
今天正式接触到java的面向对象特性，现把笔记誊抄，并做出自己对于面向对象的理解，可能不完全，请大家指出问题。
1.面向对象的概念：
将整个操作进行拆分，采用组装的形式表达。
面向对象起源与IBM的smalltalk语言，根据该语言，进而发展了c和c++(他俩主要是面向底层控制的语言，连通汇编语言)，在他们的基础之上产生了java（应用层）。其中java和c++是面向对象的语言。
特征：
1.封装：外部不可见。举例说明：我们的计算机等设备，通过机箱、壳子等包裹着硬件设备，确保设备安全稳定的运行；元器件讲究封装类似，就是就封装的含义。
2.继承：和现在通用的继承含义相同。拥有前人的基础和能力。
3多态：具有多种性态，在某个固定的范围的固定的变化，又继承来引发的。距离说明：台式电脑、笔记本、Ipad都属于电脑，但是性态不同而已。
从开发的角度把面向对象分三类，由上到下：编程-设计-分析
2.类与对象
类：描述某一具体
特征的
群体，表示一个共性产物。举例说明：人是一类、狗是一类。
对象：某一类群体的具体描述，是个性。距离说明：人类中的奥巴马、三胖等。
现有类后有对象。
类的组成：1.属性：一系列的变量，可以描述对象具体特性。人类的名字、身高、体重等等。
2.方法：一系列操作，只要是这个类产生对象，肯定包含这些方法。人类能跑、能跳等方法。
java中定义一个类的方式：
class 类名｛属性、方法｝
注意在类的定义中，方法定义不用static，但是在主方法中定义的方法必须使用static。
对象的产生格式：
类名 对象名=new 类名（）；
调用对象的格式：
对象名.属性或者对象名.方法
如果定义的时候没有给属性赋值，则使用类型的默认值。
拿出程序说明:
复制代码
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20public class Person { public static void main(String[] args) { PersonDesp per = new PersonDesp();//产生了对象 per.name= "Tyrion";<span style="white-space:pre"> </span>//调用属性 per.age= 24; per.tell(); //调用方法 } } class PersonDesp { String name; int age; public void tell() { System.out.println("姓名：" + name +" " + "年龄:" + age); } }
没有对属性进行赋值，保留默认值
复制代码
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20public class Person { public static void main(String[] args) { PersonDesp per = new PersonDesp();//产生了对象 //per.name= "Tyrion";//调用属性 //per.age= 24; per.tell(); //调用方法 } } class PersonDesp { String name; int age; public void tell() { System.out.println("姓名：" + name +" " + "年龄:" + age); } }
由于使用了new则相应的在内存中开辟了空间：
堆内存：每个对象属性，属性不同
栈内存：堆内存的地址，保存对象的名称
以图片的形式展现一下该过程。
如果没有对属性进行赋值，则per.name=null,per.age=0;
对象产生的步骤：
1.声明： 类名 对象名=null；
2.开辟： 对象名=new 类名（）；
表现如下：
注意：如果对象没有实例化就使用，那么编译不会出现问题，在执行时：空间指向异常。
![]()
复制代码
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21public class Person { public static void main(String[] args) { PersonDesp per = null; //per= new PersonDesp();//没有实例化就是使用 per.name= "Tyrion";//调用属性 per.age= 24; per.tell(); //调用方法 } } class PersonDesp { String name; int age; public void tell() { System.out.println("姓名：" + name +" " + "年龄:" + age); } }
3.引用传递
引用类都具有的特性，把一块堆内存同时给栈内存空间。引用数据操作中，没有任何指向的对象空间称为垃圾，java中的垃圾收集（GC）不定期回收，也可以人为。
复制代码
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22public class Person { public static void main(String[] args) { PersonDesp per1= new PersonDesp();//对象per1 PersonDesp per2=per1;//引用传递 per1.name= "Tyrion";//调用属性 per1.age= 24; per2.name="Mac"; per1.tell(); //调用方法 } } class PersonDesp { String name; int age; public void tell() { System.out.println("姓名：" + name +" " + "年龄:" + age); } }
以图片的形式描述以上过程，重点是对内存空间的操作进行说明。。
4.封装性
面向对象的第一个特征就是封装性，之前也已经说明了，下面说明他的重要性。
复制代码
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19public class TestClass { public static void main(String[] args) { Person per=new Person(); per.name="Tyrion"; per.age=-24; per.tell(); } } class Person { public String name; public int age; public void tell() { System.out.println("姓名：" + name +'t' + "年龄:" + age); } }
该
程序显然在年龄上存在问题（不能为负数），修改办法是在类中，对属性进行封装，使其对外面不可见，用setter和getter进行对类中属性进行赋值。
复制代码
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
39public class TestClass { public static void main(String[] args) { Person per=new Person(); per.setName("Tyrion"); per.setAge(-24); per.tell(); } } class Person { private String name; //对属性进行封装 private int age; public void tell() { System.out.println("姓名：" + name +'t' + "年龄:" + age); } public void setName(String n) //设置 { name=n; } public void setAge(int n) { if (n>=0) { age=n; } } public String getName() //获取 { return name; } public int getAge() { return age; } }
这时候能够确保封装，如果 在主程序中
per.age=33;，由于age是private形式，他只能够使用类的方法进行操作。
4.构造方法
定义：一个类的对象在使用关键字new进行实例化时，可以执行某些操作。作用：属性的初始化。
构造方法的名称和类的名称相同
构造方法没有返回值类型的声明
public 类名（）｛｝
只有进行实例化时，才调用了构造方法，同时，在类中，会默认生成一个不带参数的构造方法。
复制代码
这样给出了构造方法的说明，它的用途就是初始化属性。同时，由于他本身也是一种方法，可以进行重载操作，这里就不再过多的描述了。
在类中的方法可以相互之间调用，使用”this.“
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
42public class TestClass { public static void main(String[] args) { Person per=new Person("Tyrion",24);<span style="white-space:pre"> </span>//这样初始化的名称就会有所不同 per.tell(); } } class Person { private String name; //对属性进行封装 private int age; public void tell() { System.out.println("姓名：" + name +'t' + "年龄:" + age); } public Person(String n, int a) //使用构造方法进行初始化，有参数列表，没有返回值类型 { setName(n); setAge(a); } public void setName(String n) //设置 { name=n; } public void setAge(int n) { if (n>=0) { age=n; } } public String getName() //获取 { return name; } public int getAge() { return age; } }
例如:this.setName(n);this.setAge(m);
5.匿名对象
匿名对象是没有对象名，他至开辟了堆内存，在栈内存没有值，同时使用完毕之后，GC对其进行收集。
复制代码
以上是今天java学习的内容。健健康康，开开心心。
1
2
3
4
5
6
7public class TestClass { public static void main(String[] args) { new Person("Tyrion",24).tell(); } }
最后
以上就是热情耳机最近收集整理的关于12-5Java面向对象笔记（一）1.面向对象的概念：将整个操作进行拆分，采用组装的形式表达。2.类与对象 3.引用传递4.封装性4.构造方法5.匿名对象的全部内容，更多相关12-5Java面向对象笔记（一）1.面向对象的概念：将整个操作进行拆分，采用组装的形式表达。2.类与对象内容请搜索靠谱客的其他文章。
本图文内容来源于网友提供，作为学习参考使用，或来自网络收集整理，版权属于原作者所有。
发表评论 取消回复