面向过程和面向对象
- c语言是面向过程的，关注的是过程，分析出求解问题的步骤，通过函数调用逐步解决问题。
- 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
|
class person { public int age;//成员属性 实例变量 字段 属性 public string name; public static string sex; //静态成员变量 方法区 public void eat() {//成员方法 system.out.println("吃饭!"); } public void sleep() { system.out.println("睡觉!"); } public static void func(){ system.out.println("静态成员方法"); }}public class main{ public static void main(string[] args) { person person = new person();//通过new实例化对象 person.eat();//成员方法调用需要通过对象的引用调用 person.sleep();//产生对象 实例化对象 person person2 = new person(); person person3 = new person(); //静态成员变量和方法的调用 system.out.println(person.sex); person.func(); }} |
成员变量：
定义在类的内部，方法的外部
通过对象的引用来访问
如果没有初始化，那么它的值就是一个默认默认值（默认零值）
- 如果是引用类型，那么值就是null（包括数组，string字符串等）
- 如果是简单类型，那么值就是其这种类型所对应的默认值
| byte | short | int | long | float | double | char | boolean |
|---|---|---|---|---|---|---|---|
| 0 | 0 | 0 | 0l | 0.0f | 0.0 | '\u0000'十六进制（也可以当作0） | false |
行为/方法：
【eat() sleep()】为实例成员方法
func()为静态成员方法
对于静态的成员变量和成员方法该该怎么访问呢
这里可以看到，对于静态的，不需要实例化对象！！！
直接调用
类名.静态成员变量/静态成员方法
总结static：
- 对于静态的成员属性或者静态的成员方法，是不依赖于对象的。
- 静态的成员变量 ，只有一份，存储在方法区中。
- 静态的方法内部是不可以访问非静态的数据的。
实例化类的存储结构
初始化成员变量的方式
1、就地初始化（在类内进攻初始化）
2、默认初始化
3、类外初始化（用的比较多）
|
1
2
3
4
5
6
7
8
9
10
11
|
public class main{ public static void main(string[] args) { person person1 = new person(); person1.name = "星星"; person1.age = 20; person person2 = new person(); person2.name = "狒狒"; person2.age = 40; }} |
封装
在我们写代码的时候经常会涉及两种角色: 类的实现者和类的调用者. 封装的本质就是让类的调用者不必太多的了解类的实现者是如何实现类的,只要知道如何使用类就行了.
这样就降低了类使用者的学习和使用成本, 从而降低了复杂程度
private/ public 这两个关键字表示 “访问权限控制” .
- 被 public 修饰的成员变量或者成员方法, 可以直接被类的调用者使用.
- 被 private 修饰的成员变量或者成员方法,不能被类的调用者使用
举个例子
|
1
2
3
4
5
6
7
8
9
10
11
12
13
|
class person { private string name = "张三"; private int age = 18; public void show() { system.out.println("我叫" + name + ", 今年" + age + "岁"); }}class test { public static void main(string[] args) { person person = new person(); person.show(); }} |
- 此时字段已经使用 private 来修饰. 类的调用者(main方法中)不能直接使用. 而需要借助 show 方法. 此时类的使用者就不必了解 person 类的实现细节.
- 同时如果类的实现者修改了字段的名字, 类的调用者不需要做出任何修改(类的调用者根本访问不到 name, age这样的字段)
getter和setter方法
getter：得到属性值的方法
setter：修改属性值的方法
我们用这两者方法将类的属性封装起来，从而来达到访问属性的目的
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
|
class person { private string name;//实例成员变量 private int age; public void setname(string name){//name = name;//不能这样写 this.name = name;//this引用，表示调用该方法的对象 } public string getname(){ return name; } public void show(){ system.out.println("name: "+name+" age: "+age); }}class main { public static void main(string[] args) { person person = new person(); person.setname("caocao"); string name = person.getname(); system.out.println(name); person.show(); }} |
this关键字
我们在刚才的代码可以看到setter方法
|
1
2
3
4
5
|
private string name;public void setname(string name){ //name = name;//不能这样写 this.name = name;//this引用，表示调用该方法的对象} |
this表示当前对象引用， 可以借助 this 来访问对象的字段和方法
三个用法：
- this.属性; //访问当前对象的属性
- this.方法；//调用当前对象的方法
- this(); //调用当前对象的构造方法 （ps：必须放在第一行，且只能存在一个构造方法内部）
构造方法
构造方法是一种特殊方法, 使用关键字new实例化新对象时会被自动调用, 用于完成初始化操作
实例化一个对象/创建一个对象分几步？
student stu = new student() ；//实例化一个对象
两步
- 为对象分配内存
- 调用合适的构造方法，说明构造方法不止一个，可能更多
语法规则
- 方法名称必须与类名称相同
- 构造方法没有返回值类型声明
- 每一个类中一定至少存在一个构造方法（没有明确定义，则系统自动生成一个无参构造）
|
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
|
class person { private string name;//实例成员变量 private int age; private string sex; //默认构造函数 构造对象 public person() { this.name = "caocao"; this.age = 10; this.sex = "男"; } //带有3个参数的构造函数 public person(string name,int age,string sex) { this.name = name; this.age = age; this.sex = sex; } public void show(){ system.out.println("name: "+name+" age: "+age+" sex: "+sex); }}public class main{ public static void main(string[] args) { person p1 = new person();//调用不带参数的构造函数 如果程序没有提供会调用不带参数的构造函数 p1.show(); person p2 = new person("zhangfei",80,"男");//调用带有3个参数的构造函数 p2.show(); }} |
tostring方法
|
1
2
|
person person = new person("caocao",19);system.out.println(person); |
如果打印引用，他会默认调用tostring方法，执行这样一个结果：
我们可以重写tostring方法，来打印自己想要的结果
例如：
|
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
|
class person { private string name; private int age; public person(string name,int age) { this.age = age; this.name = name; } public void show() { system.out.println("name:"+name+" " + "age:"+age); } //重写object的tostring方法 @override public string tostring() { return "person{" + "name='" + name + '\'' + ", age=" + age + '}'; }}public class main { public static void main(string[] args) { person person = new person("caocao",19); person.show(); system.out.println(person); }} |
这样打印引用的化，就会按照想要的内容进行输出。
匿名对象
匿名只是表示没有名字的对象.
- 没有引用的对象称为匿名对象.
- 匿名对象只能在创建对象时使用.
- 如果一个对象只是用一次, 后面不需要用了, 可以考虑使用匿名对象
|
1
|
new person("caocao",19).show();//通过匿名对象调用方法 |
特点：不依赖于对象，我们只需要通过类名就可以调用其属性或者方法
代码块
- 本地代码块
- 静态代码块
- 实例代码块/构造代码块
- 同步代码块（多线程）
本地代码块： 在方法中的代码块
|
1
2
3
4
5
6
7
8
9
10
|
public class main{ public static void main(string[] args) { { //直接使用{}定义，普通方法块 int x = 10 ; system.out.println("x1 = " +x); } int x = 100 ; system.out.println("x2 = " +x); }} |
静态代码块： 一般用于初始化静态成员属性
|
1
2
3
4
5
|
//静态代码块static {count = 10;//只能访问静态数据成员system.out.println("i am static init()!");} |
实例代码块： 定义在类中的代码块，构造代码块一般用于初始化实例成员变量
|
1
2
3
4
5
6
7
|
//实例代码块{this.name = "bit";this.age = 12;this.sex = "man";system.out.println("i am instance init()!");} |
执行顺序
静态代码块实例代码块构造方法
总结
到此这篇关于java中类和对象的文章就介绍到这了,更多相关java类和对象内容请搜索服务器之家以前的文章或继续浏览下面的相关文章希望大家以后多多支持服务器之家！
原文链接：https://blog.csdn.net/starry1441/article/details/113757382
