Java学习 java -- 面向对象

面向对象 

在过去学过的C语言当中 我们所用的编程思想是用的面向过程的思想，例如在生活中我们买衣服，首先我们要确定要买的衣服，怎么买 一步一步的罗列出来直至买到衣服这个一系列过程就是面对过程的思想，那么面对对象是什么样地一种思想呢？

面向对象就是将这些要想实现的功能找一个可以完成这项功能的对象来实现，简单的说就是例如你买衣服，不用你自己一步一步的操作，只要找到一个帮你买衣服的人就可以了，你找的这个人就可以是一个对象。 这就是面向对象的思想，

面向对象的好处： 

1.将复杂的问题 简单化 

2.从事物的执行者 转变为 指挥者 

3.面向对象的思想 是 更贴近人思考问题的思想（懒人思想）

在之前说过面向对象是一种思想也是指一种程序设计范型，同时也是一种程序开发的方法那这种程序开发的方法怎么实现的呢 这里牵扯到两个名词就是 对象 和 类

1.类： 

什么是类呢？

例如：   描述  一类人，  学生姓名、性别、年龄、身高、学号
这些学生都能干些什么呢？
去上课、睡觉、逃课（我的大学生活……）

1
2
3
4

在这里我们可以把“学生”看做一个类，在这个“学生”中具体包含了有姓名、性别、年龄、身高、学号等，这一系列名词 这个是“学生”类的属性。也包含着学生可以做的一些事情，这些所做的事情就是“学生”类的行为。

2.对象 

什么是对象呢？在说过类之后对象就非常好理解了，对象就是把类具体到一个单位 

比如：“学生”类具体到一个学生：

描述  一个学生       姓名、性别、年龄、身高、学号
这些学生都能干些什么呢？
去上课、睡觉、逃课

1
2
3
4

将类中抽象的一类事物具体到一个的时候我们称之为对象。

那么类就是具有相同属性（数据元素）和行为（功能）的对象的抽象就是类。因此，对象的抽象是类，类的具体化就是对象，也可以说类的实例是对象，类实际上就是一种数据类型。

首先先说一下在 java中 最基本的单位—— 类： 

1.成员变量（实例变量） 相当于属性 

书写位置：在类中，方法外

2.成员方法 相当于行为 

目前成员方法跟函数写法一样 只是少一个static

面向对象的设计 

1.维护类和对象之间的关系 

2.不断的操作对象 使用对象 指挥对象去完成一些功能

例 创建一个类 

需求：写一个学生类 

成员变量：姓名 年龄 性别 

成员方法：吃饭 睡觉 听课

//  创建了一个Student类
//  在同一个文件下 可以有很多类
//  只能有一个public定义的类
class Student{

//  成员变量
String name;   //  姓名
int age;       //  年龄
String gender; //  性别

//  成员方法
//  关键字  返回值类型 方法名（参数列表）{方法体}
public void eat() {
System.out.println("吃饭");
}
public void sleep() {
System.out.println("睡觉");
}
public void lenson() {
System.out.println("听课");
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23

}

类已经创建好了，那么接下来的问题是 如何在main函数中使用这个类来具体实例到一个对象呢？换句话说，如何使用类呢？

public static void main(String[] args) {

//  创建一个学生对象

//  类名 对象名 = new 类名（）；
// **new一次  产生一个对象**
Student stu = new Student();
//  使用成员变量 对象点成员变量
stu.name = "zhangsan";
stu.name = "lisi";  // **修改上一个变量  并不是创建一个新的变量**
stu.age = 18;
stu.gender = "男";
System.out.println(stu.name);
System.out.println(stu.age);
System.out.println(stu.gender);
//  使用成员方法  对象点方法
stu.eat();//  注意：调用无参方法 括号必须带上
stu.sleep();
stu.lenson();
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21



在这里存在一个问题就是为什么“zhangsan”为什么没有打印出来？



在我们使用new的时候系统会在堆内存中开辟一个空间，这里new一次，就会产生一个对象，在第二次赋值给stu.name的时候，仅仅是在之前的赋值的后进行的一次修改，所以没有输出“zhangsan”。 

这是一个对象在内存中的表现 那么两个对象在内存是一个什么一个表现呢？

public static void main(String[] args) {
Car qiche = new Car();
qiche.name = "布加迪";
qiche.color = "黑色";
qiche.number = 4;
qiche.air = 10.0;
System.out.println(qiche.name + qiche.color + qiche.name + qiche.air);

Car qiche2 = new Car();
qiche2.name = "兰博基尼";
qiche2.color = "蓝色";
qiche2.sayHi();

//  两个对象 三个引用
Car qiche3 = qiche2;
qiche3.sayHi();
}
}
class Car{
//  声明成员变量时  可以给一个初值
String name = "法拉利";
String color = "红色";
int number;
Double air;

public void wield() {
System.out.println("可以行使");
}
public void game() {
System.out.println("可以赛车");
}
public void leave() {
System.out.println("可以存放物品");
}

//  介绍自己的方法
public void sayHi() {
System.out.println(name + "---" + color);
}

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

} 

打印结果 





这里的方法区简单的来说 存放的是.class文件，三者之间的运行过程 



成员变量 和 局部变量 区别

书写位置不同
局部变量：方法中 或者  在方法的声明中
成员变量：在类中  方法外

初始化值不同
局部变量：必须给定初识值  才能进行使用
成员变量：只要你创建了对象  就会有默认的初始值

内存存在的位置不同
局部变量：存储在栈内存中
成员变量：存储在堆内存中

生命周期不同
（对变量的访问时  要考虑一下生命周期问题 是否可以访问）
局部变量：随着方法的入栈儿出生，随着方法的出栈而死亡
成员变量：随着对象的出生儿出生，随着对象的死亡而死亡

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

匿名对象： 

例

public class PersonDemo {
//  赋值name 调用sayHi
public static void fun(String name, Person p) {
p.name = name;
p.sayHi();
}

public static void main(String[] args) {

Person p1 = new Person();
p1.name = "梁哥";
p1.sayHi();

Person p2 = new Person();
p2.name = "韩寒";
p2.sayHi();

Person p3 = new Person();
fun("张三", p3);

fun("李四", new Person());
//  相同语句 可以抽成一个方法
//  增加代码的复用性

new Person().sayHi();
new Person().name = "卫星";
new Person().sayHi();
// TODO Auto-generated method stub

}

}

class Person{
String name;
int age;

//  介绍自己的方法
public void sayHi() {
System.out.println(name + "---" + age);
}
}

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

好处：节省代码 使用方便 

用处：当你只调用一个方法时使用， 如果你要反复调用一个方法 比较浪费内存空间 

匿名函数在函数的调用时，当参数是对象名、用的比较多

面向对象的特征： 

1.封装 

2.继承 

3.多态

首先来说一下封装

封装 

把属性和方法的具体实现隐藏 开放公共访问的方法 

例：

public class PhoneDemo {
public static void main(String[] args) {
Phone phone = new Phone();
phone.setName("oppo");

phone.color = "黑色";
phone.sayHi();
System.out.println(phone.getName());
phone.fun();

Phone phone2 = new Phone();
phone.setName("华为");
System.out.println(phone2.getName());
}
}

class Phone{
private String name;
String color;

//  通过这个方法来  修改属性
//  获取值 get...  方法名字
//  修改值 set...  方法名字

//  修改
public void setName(String name) {
//  修改属性的值

//  this关键字
//  this 代表本类的对象  对象点属性
//  this.name获取就是 成员变量的name
this.name = name;
}
//  获取
public String getName() {
return this.name;
}
public void sayHi() {
System.out.println(this.name + "---" + color);
}
public void fun() {
System.out.println(this.name);
//  就近原则，在运行到这时 先找局部变量，若没有，再找成员变量，都没有  报错
String name = "vivo";
System.out.println(name);
}

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

}

其中： private（权限修饰符） 系统关键字 

属性添加private 这个关键字 变成私有的属性，私有属性 本类中 可以访问 本类以外访问不到

如何访问 private 修饰的成员变量 

1.获取 — — get（）方法 

2.修改 — — set（）方法 

在书写代码过程中 获取和修改都是成对出现的

this关键字的使用

this就是当前这个类，你可以this.成员变量在方法中使用这个成员变量，当然this.也是可以省略的，如果与局部变量同名，可以加this.来区分。

成员变量私有化 是封装的一种表现形式， 私有化之后 必须要写 set/get方法