Java从入门到天黑|05JavaSE入门之面向对象（上）

Posted 2021-06-27 孙叫兽

面向过程&面向对象

语言的进化发展跟生物的进化发展其实是一回事，都是”物以类聚”。相近的感光细胞聚到一起变成了我 们的眼睛，相近的嗅觉细胞聚到一起变成了我们的鼻子。
语句多了，我们将完成同样功能的相近的语句，聚到了一块儿，便于我们使用。于是，方法出现了！ 变量多了，我们将功能相近的变量组在一起，聚到一起归类，便于我们调用。于是，结构体出现了！
再后来，方法多了，变量多了！结构体不够用了！我们就将功能相近的变量和方法聚到了一起，于是类 和对象出现了！
寥寥数语，就深刻的展示了语言的进化历史！其实，都非常自然，”物以类聚”。希望大家能记住这句 话。
企业的发展也是”物以类聚”的过程，完成市场推广的人员聚到一起形成了市场部。完成技术开发的人员 聚到一起形成了开发部！
面向过程的思维模式
面向过程的思维模式是简单的线性思维，思考问题首先陷入第一步做什么、第二步做什么的细节中。这 种思维模式适合处理简单的事情，比如：上厕所。
如果面对复杂的事情，这种思维模式会陷入令人发疯的状态！比如：如何造神舟十号！
面向对象的思维模式
面向对象的思维模式说白了就是分类思维模式。思考问题首先会解决问题需要哪些分类，然后对这些分 类进行单独思考。最后，才对某个分类下的细节进行面向过程的思索。
这样就可以形成很好的协作分工。比如：设计师分了10个类，然后将10个类交给了10个人分别进行详细 设计和编码！
显然，面向对象适合处理复杂的问题，适合处理需要多人协作的问题！
如果一个问题需要多人协作一起解决，那么你一定要用面向对象的方式来思考！
对于描述复杂的事物，为了从宏观上把握、从整体上合理分析，我们需要使用面向对象的思路来分析整 个系统。但是，具体到微观操作，仍然需要面向过程的思路去处理。

OOP详解

1、什么是面向对象
Java的编程语言是面向对象的，采用这种语言进行编程称为面向对象编程(Object-Oriented Programming, OOP)。
面向对象编程的本质就是：以类的方式组织代码，以对象的组织(封装)数据。
抽象(abstract)

1 忽略一个主题中与当前目标无关的那些方面，以便更充分地注意与当前目标有关的方面。抽象并不打算了
解全部问题，而只是选择其中的一部分，暂时不用关注细节。
2 例如:要设计一个学生成绩管理系统，那么对于学生，只关心他的班级、学号、成绩等，而不用去关心他的
身高、体重这些信息。 抽象是什么?就是将多个物体共同点归纳出来，就是抽出像的部分！
封装(Encapsulation)
封装是面向对象的特征之一，是对象和类概念的主要特性。封装是把过程和数据包围起来，对数据的访 问只能通过指定的方式。
在定义一个对象的特性的时候，有必要决定这些特性的可见性，即哪些特性对外部是可见的，哪些特性 用于表示内部状态。
通常，应禁止直接访问一个对象中数据的实际表示，而应通过操作接口来访问，这称为信息隐藏。 信息隐藏是用户对封装性的认识，封装则为信息隐藏提供支持。
封装保证了模块具有较好的独立性，使得程序维护修改较为容易。对应用程序的修改仅限于类的内部， 因而可以将应用程序修改带来的影响减少到最低限度。
继承(inheritance)

继承是一种联结类的层次模型，并且允许和支持类的重用，它提供了一种明确表述共性的方法。
新类继承了原始类后,新类就继承了原始类的特性，新类称为原始类的派生类(子类)，而原始类称为新 类的基类(父类)。
派生类(子类)可以从它的基类(父类)那里继承方法和实例变量，并且派生类(子类)中可以修改或增
加新的方法使之更适合特殊的需要继承性很好的解决了软件的可重用性问题。比如说，所有的Windows应
用程序都有一个窗口，它们可以看作都是从一个窗口类派生出来的。但是有的应用程序用于文字处理，有
的应用程序用于绘图，这是由于派生出了不同的子类，各个子类添加了不同的特性。

多态(polymorphism)

多态性是指允许不同类的对象对同一消息作出响应。
多态性语言具有灵活、抽象、行为共享、代码共享的优势，很好的解决了应用程序函数同名问题。

相同类域的不同对象,调用相同方法,表现出不同的结果
从认识论角度考虑是先有对象后有类。对象，是具体的事物。类，是抽象的，是对对象的抽象。 从代码运行角度考虑是先有类后有对象。类是对象的模板。

2、类与对象的关系

类是一种抽象的数据类型,它是对某一类事物整体描述/定义,但是并不能代表某一个具体的事物.

例如：我们生活中所说的词语：动物、植物、手机、电脑等等。这些也都是抽象的概念,而不是指的某一个 具体的东西。

例如: Person类、Pet类、Car类等，这些类都是用来描述/定义某一类具体的事物应该具备的特点和行为对象是抽象概念的具体实例
例如：张三就是人的一个具体实例,张三家里的旺财就是狗的一个具体实例。能够体现出特点,展现出功能 的是具体的实例,而不是一个抽象的概念.

【示例】

1	Student s = new Student(1L,"tom",20);
2	s.study();
3	
4	Car c = new Car(1,"BWM",500000);
5	c.run();

对象s就是Student类的一个实例,对象c就是Car类的一个具体实例,能够使用的是具体实例,而不是类。类 只是给对象的创建提供了一个参考的模板而已.
但是在java中,没有类就没有对象,然而类又是根据具体的功能需求,进行实际的分析,最终抽象出来的.

3、对象和引用的关系

引用 “指向” 对象
使用类类型、数组类型、接口类型声明出的变量,都可以指向对象,这种变量就是引用类型变量,简称引 用。
在程序中,创建出对象后,直接使用并不方便,所以一般会用一个引用类型的变量去接收这个对象,这个就是 所说的引用指向对象.
总结:对象和引用的关系,就如电视机和遥控器,风筝和线的关系一样。
方法回顾及加深

方法一定是定义在类中的,属于类的成员。
1、方法的定义

格式： 修饰符 返回类型 方法名(参数列表)异常抛出类型{…}

1.修饰符

1 public、static、abstract、final等等都是修饰符，一个方法可以有多个修饰符。例如程序入口
main方法，就使用了public static这个俩个修饰符 2 注:如果一个方法或者属性有多个修饰符,这多个修饰符是没有先后顺序的

2.返回类型

1 方法执行完如果有要返回的数据,那么就要声明返回数据的类型,如果没有返回的数据,那么返回类型就必须写void.
2 只有构造方法(构造器)不写任何返回类型也不写void

【示例】

public String sayHello(){ return "hello";
}
public int max(int a,int b){ return a>b?a:b;
}
public void print(String msg){ System.out.println(m

思考：声明返回类型的方法中一定要出现return语句,那么没有返回类型(void)的方法中,能不能出现return语句?
注：break和return的区别

return 语句的作用
(1) return 从当前的方法中退出,返回到该调用的方法的语句处,继续执行。
(2) return返回一个值给调用该方法的语句，返回值的数据类型必须与方法的声明中的返回值的类型一致。
(3)return后面也可以不带参数，不带参数就是返回空，其实主要目的就是用于想中断函数执行，返回调用函数处。
break语句的作用
(1)break在循环体内，强行结束循环的执行，也就是结束整个循环过程，不在判断执行循环的条件是否成立，直接转向循环语句下面的语句。
(2)当break出现在循环体中的switch语句体内时，其作用只是跳出该switch语句体。

3.方法名

遵守java中标示符的命名规则即可

4.参数列表

根据需求定义,方法可以是无参的,也可以有一个参数,也可以有多个参数

5.异常抛出类型

如果方法中的代码在执行过程中,可能会出现一些异常情况,那么就可以在方法上把这些异常声明并抛出,
也可以同时声明抛出多个异常,使用逗号隔开即可。

【示例】

1	public void readFile(String file)throws IOException{
2
3	}
4	
5	public void readFile(String file)throws IOException,ClassNotFoundException{
6	
7	}

2、方法调用

在类中定义了方法,这个方法中的代码并不会执行,当这个方法被调用的时候,方法中的代码才会被一行一 行顺序执行。
1.非静态方法

1 没有使用static修饰符修饰的方法,就是非静态方法.
2 调用这种方法的时候,是"一定"要使用对象的。因为非静态方法是属于对象的。(非静态属性也是一样的)

【例子】

1	public class Student{
2	public void say(){}
3	}
4	
5	main:
6	Student s = new Student();
7	s.say();

静态方法

1 使用static修饰符修饰的方法,就是静态方法.
2 调用这种方法的时候,"可以"使用对象调用,也"可以"使用类来调用,但是推荐使用类进行调用,因为静态方法是属于类的。(静态属性也是一样的)

【例子】

1	public class Student{
2	public static void say(){}
3	}
4	
5	main:
6	Student.say();

3.类中方法之间的调用
假设同一个类中有俩个方法,a方法和b方法，a和b都是非静态方法，相互之间可以直接调用。

1	public void a(){
2	b();
3	}
4	public void b(){
5	
6	}

a和b都是静态方法,相互之间可以直接调用.

1	public static void a(){
2	b();
3	}
4	public static void b(){
5	
6	}

a静态方法,b是非静态方法，a方法中不能直接调用b方法,但是b方法中可以直接调用a方法. 静态方法不能调用非静态方法！

public static void a(){
//b();报错
}
public void b(){ a();
}

另外：在同一个类中,静态方法内不能直接访问到类中的非静态属性.
总结：类中方法中的调用，两个方法都是静态或者非静态都可以互相调用，当一个方法是静态，一个方 法是非静态的时候，非静态方法可以调用静态方法，反之不能。
3、调用方法时的传参
1.形参和实参
【例子】

// a = x;
public void test(int a){
//..
}
main:
int x = 1; t.test(x);

参数列表中的a是方法test的形参(形式上的参数) 调用方法时的x是方法test的实参(实际上的参数)
注意：形参的名字和实参的名字都只是一个变量的名字,是可以随便写的,我们并不关心这个名字,而是关 心变量的类型以及变量接收的值。
2.值传递和引用传递
调用方法进行传参时,分为值传递和引用传递两种。
如果参数的类型是基本数据类型,那么就是值传递。如果参数的类型是引用数据类型,那么就是引用传递。
值传递是实参把自己变量本身存的简单数值赋值给形参.
引用传递是实参把自己变量本身存的对象内存地址值赋值给形参.
所以值传递和引用传递本质上是一回事,只不过传递的东西的意义不同而已.
【示例：值传递】

public class Test{
public static void changeNum(int a){
a = 10;
}

public static void main(String[] args){
int a = 1;
System.out.println("before: a = "+a); //1
changeNum(a);
System.out.println("after: a = "+a);	//1
}
}

【示例：引用传递】

public class Demo03 {

public static void changeName(Student s){
s.name = "tom";
}

public static void main(String[] args){
Student s = new Student();
System.out.println("before: name = "+s.name); //null
changeName(s);
System.out.println("after: name = "+s.name); //tom
}
}

class Student{
String name;}

4、this关键字

在类中,可以使用this关键字表示一些特殊的作用。
1、this在类中的作用
【区别成员变量和局部变量】

public class Student{ private String name;
public void setName(String name){
//this.name表示类中的属性name this.name = name;
}

【调用类中的其他方法】

public class Student{ private String name;
public void setName(String name){ this.name = name;
}
public void print(){
//表示调用当前类中的setName方法this.setName("tom");
}

注：默认情况下,setName(“tom”)和this.setName(“tom”)的效果是一样的.
【调用类中的其他构造器】

public class Student{ private String name; public Student(){
//调用一个参数的构造器,并且参数的类型是String
this("tom");
}
public Student(String name){ this.name = name;
}

注:this的这种用法,只能在构造器中使用.普通的方法是不能用的.并且这局调用的代码只能出现在构造器 中的第一句.
【示例】

public class Student{ private String name;
//编译报错,因为this("tom")不是构造器中的第一句代码.
public Student(){ System.out.println("hello"); this("tom");
}
public Student(String name){ this.name = name;
}
}

2、this关键字在类中的意义
this在类中表示当前类将来创建出的对象.
【例子】

public class Student{ private String name; public Student(){
System.out.println("this = "+this);
}
public static void main(String[] args){ Student s = new Student(); System.out.println("s = "+s);
}

运行后看结果可知,this和s打印的结果是一样的,那么其实也就是变量s是从对象的外部执行对象,而this是 在对象的内部执行对象本身.
这样也就能理解为什么this.name代表的是成员变量,this.setName(“tom”)代表的是调用成员方法,因为 这俩句代码从本质上讲,和在对象外部使用变量s来调用是一样的,s.name和s.setName(“tom”)。
【this和s打印出来的内存地址是一样的,使用==比较的结果为true。】

public class Student{
public Student getStudent(){
return this;
}

public static void main(String[] args) {
Student s1 = new Student();
Student s2 = s1.getStudent();
System.out.println(s1 == s2);//true
}
}

【 类中的this是和s1相等还是和s2相等呢?】

public class Student{ private String name; public void test(){
System.out.println(this);
}
public static void main(String[] args) { Student s1 = new Student();
Student s2 = new Student(); s1.test();
s2.test();
}

注:这句话是要这么来描述的,s1对象中的this和s1相等,s2对象中的this和s2相等,因为类是模板,模板中写 的this并不是只有一个,每个对象中都有一个属于自己的this,就是每个对象中都一个属于自己的name属性 一样.

创建与初始化对象

使用new关键字创建对象
使用new关键字创建的时候，除了分配内存空间之外，还会给 创建好的对象 进行默认的初始化 以 及对类中构造器的调用

那么对main方法中的以下代码: Student s = new Student();

1)为对象分配内存空间,将对象的实例变量自动初始化默认值为0/false/null。(实例变量的隐式赋 值)

2)如果代码中实例变量有显式赋值,那么就将之前的默认值覆盖掉。(之后可以通过例子看到这个现象) 例如:显式赋值 private String
name = “tom”;

3)调用构造器

4)把对象内存地址值赋值给变量。(=号赋值操作)
构造器

类中的构造器也称为构造方法，是在进行创建对象的时候必须要调用的。并且构造器有以下俩个特点:
1.必须和类的名字相同
2.必须没有返回类型,也不能写void
构造器的作用:
1.使用new创建对象的时候必须使用类的构造器
2.构造器中的代码执行后,可以给对象中的属性初始化赋值
【演示】

public class Student{ private String name; public Student(){
name = "tom";
}
}

构造器重载
除了无参构造器之外,很多时候我们还会使用有参构造器,在创建对象时候可以给属性赋值.
【例子】

public class Student{
private String name;

public Student(){
name = "tom";
}

public Student(String name){
this.name = name;
}
}

构造器之间的调用
使用this关键字,在一个构造器中可以调用另一个构造器的代码。
注意:this的这种用法不会产生新的对象,只是调用了构造器中的代码而已.一般情况下只有使用new关键 字才会创建新对象。
【演示】

public class Student{ private String name; public Student(){
this();
}
public Student(String name){ this.name = name;
}

默认构造器
在java中,即使我们在编写类的时候没有写构造器,那么在编译之后也会自动的添加一个无参构造器,这个 无参构造器也被称为默认的构造器。
【示例】

public class Student{

}

main:
//编译通过,因为有无参构造器
Student s = new Student();

但是,如果我们手动的编写了一个构造器,那么编译后就不会添加任何构造器了
示例：

public class Student{
private String name;
public Student(String name){
this.name = name;
}
}

main:
//编译报错,因为没有无参构造器
Student s = new Student();

内存分析

JAVA程序运行的内存分析
栈 stack：
1.每个线程私有，不能实现线程间的共享！
2.局部变量放置于栈中。
3.栈是由系统自动分配，速度快！栈是一个连续的内存空间！
堆 heap：
1.放置new出来的对象！
2.堆是一个不连续的内存空间，分配灵活，速度慢！
方法区(也是堆)：
1.被所有线程共享！
2.用来存放程序中永远是不变或唯一的内容。（类代码信息、静态变量、字符串常量）

注意：本次内存分析，我们的主要目的是让大家了解基本的内存概念。类加载器、Class对象这些更加详 细的内容，我们将在后面专门讲反射的课程里面讲。
引用类型的概念
1.java中，除了基本数据类型之外的其他类型称之为引用类型。
2.java中的对象是通过引用来操作的。(引用：reference)说白了，引用指的就是对象的地址！
属性（field，或者叫成员变量）
1.属性用于定义该类或该类对象包含的数据或者说静态属性。
2.属性作用范围是整个类体。
3.属性的默认初始化
在定义成员变量时可以对其初始化，如果不对其初始化，Java使用默认的值对其初始化。(数值：0,0.0 char:u0000, boolean:false, 所有引用类型:null)
4.属性定义格式

[修饰符] 属性类型 属性名 = [默认值]

类的方法
方法是类和对象动态行为特征的抽象。方法很类似于面向过程中的函数。面向过程中，函数是最基本单 位，整个程序有一个个函数调用组成；面向对象中，整个程序的基本单位是类，方法是从属于类或对象 的。
方法定义格式

[修饰符] 方法返回值类型
// n条语句
}

java对象的创建和使用
必须使用 new 关键字创建对象。
Person person= new Person ();
使用对象（引用） . 成员变量来引用对象的成员变量。
person.age
使用对象（引用） . 方法（参数列表）来调用对象的方法。
1.setAge(23)
类中就是：//静态的数据 //动态的行为
学习完类与对象终于认识到什么是类，什么是对象了。接下来要看的就是java的三大特征：继承、封 装、多态。
封装

我要看电视，只需要按一下开关和换台就可以了。有必要了解电视机内部的结构吗？有必要碰碰显像管 吗？
制造厂家为了方便我们使用电视，把复杂的内部细节全部封装起来，只给我们暴露简单的接口，比如： 电源开关。需要让用户知道的暴露出来，不需要让用户了解的全部隐藏起来。这就是封装。
白话：该露的露，该藏的藏
专业：我们程序设计要追求“高内聚，低耦合”。高内聚就是类的内部数据操作细节自己完成，不允许外 部干涉；低耦合：仅暴露少量的方法给外部使用。
封装（数据的隐藏）
在定义一个对象的特性的时候，有必要决定这些特性的可见性，即哪些特性对外部是可见的，哪些特性 用于表示内部状态。
通常，应禁止直接访问一个对象中数据的实际表示，而应通过操作接口来访问，这称为信息隐藏。
1、封装的步骤
1.使用private 修饰需要封装的成员变量
2.提供一个公开的方法设置或者访问私有的属性
设置 通过set方法，命名格式： set属性名（）; 属性的首字母要大写
访问 通过get方法，命名格式： get属性名（）; 属性的首字母要大写
【演示】

//对象能在类的外部"直接"访问public class Student{
public String name; public void println(){
System.out.println(this.name);
}
}
public class Test{
public static void main(String[] args){ Student s = new Student();
s.name = "tom";
}
}

在类中一般不会把数据直接暴露在外部的,而使用private(私有)关键字把数据隐藏起来
【演示】

public class Student{
private String name;
}

public class Test{
public static void main(String[] args){
Student s = new Student();
//编译报错,在类的外部不能直接访问类中的私有成员
s.name = "tom";
}
}

如果在类的外部需要访问这些私有属性,那么可以在类中提供对于的get和set方法,以便让用户在类的外部 可以间接的访问到私有属性
【示例】

1	//set负责给属性赋值
2	//get负责返回属性的值
3	public class Student{
4	private String name;
5	public void setName(String name){
6	this.name = name;
7	}
8	public String getName(){
9	return this.name;
10	}
11	}
12	
13	public class Test{
14	public static void main(String[] args){
15	Student s = new Student();
16	s.setName("tom");
17	System.out.println(s.getName());
}}

2、作用和意义
1.提高程序的安全性，保护数据。
2.隐藏代码的实现细节
3.统一用户的调用接口
4.提高系统的可维护性
5.便于调用者调用。
良好的封装，便于修改内部代码，提高可维护性。
良好的封装，可进行数据完整性检测，保证数据的有效性。
3、方法重载
类中有多个方法,有着相同的方法名,但是方法的参数各不相同,这种情况被称为方法的重载。方法的重载 可以提供方法调用的灵活性。
思考：HelloWorld中的System.out.println()方法，为什么可以把不同类型的参数传给这个方法?
【演示：查看println方法的重载】例如:

public class Test{
public void test(String str){

}
public void test(int a){
}
}

方法重载必须满足以下条件
1.方法名必须相同
2.参数列表必须不同(参数的类型、个数、顺序的不同)

public	void	test(Strig str){}
public	void	test(以上是关于Java从入门到天黑|05JavaSE入门之面向对象（上）的主要内容，如果未能解决你的问题，请参考以下文章
 
 Java从入门到天黑|05JavaSE入门之面向对象（上）
 Java从入门到天黑|05JavaSE入门之面向对象（上）
 Java从入门到天黑|04JavaSE入门之数组
 Java从入门到天黑|04JavaSE入门之数组
 Java从入门到天黑|03JavaSE入门之流程控制
 JavaSE入门学习15：Java面向对象之继承