面向过程&&面向对象
语言的进化发展跟生物的进化发展其实是一回事,都是“物以类聚”。相近的感光细胞聚到一起变成了我们的眼睛,相近的嗅觉细胞聚到一起变成了我们的鼻子。
语句多了,我们将完成同样功能的相近语句,聚到了一块儿,便于我们使用。于是,方法出现了。
变量多了,我们将功能相近的变量组在一起,聚到一起归类,便于我们调用。于是,结构体出现了。
方法多了,变量多了,结构体不够用了,我们就将功能相近的变量和方法聚到一起,于是类和对象出现了。
寥寥数语,就深刻的展示了语言的进化历史。其实都非常自然,“物以类聚”。
企业的发展也是“物以类聚”的过程,完成市场推广的人员聚到一起形成了市场部。完成技术开发的人员聚到了一起形成了开发部。
面向过程的思维模式
面向对象的思维模式是简单的线性思维,思考问题首先陷入第一步干什么、第二步做什么细节中。这种思维模式适合处理简单的事情。
如果面对复杂的事情,这种思维模式会陷入令人发疯的状态。比如:如何造火箭。
面向对象的思维模式
面向对象的思维模式说白了就是分类思维模式。思考问题首先会解决问题需要哪些分类,然后对这些分类进行单独思考。最后,才对某个分类下的世界进行面向过程的思索。
这样就可以形成很好的协作分工。比如:设计师分了10个类,然后将10个类交给了10个人分别进行详细设计和编码。
显然,面向对象适合处理复杂的问题,适合处理需要多个协作的问题。
如果一个问题需要多个人协作一起解决,那么你一定要用面向对象的方式来思考。
对于描述复杂的事物,为了从宏观上把握,从整体上合理分析,我们需要使用面向对象的思路来分析整个系统。但是,具体到微观操作,仍然需要面向过程的思路去处理。
OOP详解
1、什么是面向对象
Java的编程语言是面向对象的,采用这种语言进行编程称为面向对象编程(Object-Oriented Programming,OOP)
面向对象编程的本质就是:以类的方式组织代码,以对象的组织(封装)数据。
抽象(abstract)
- 忽略一个主题中与当前目标无关的那些方面,以便更充分的注意与当前目标有关的方面。抽象并不打算了解全部问题,而是选择其中的一部分,暂时不用关注细节。
- 例如:要设计一个学生管理系统,那么对于学生,只关心他的班级、学号、成绩等,而不用去关心他的身高、体重这些信息。抽象是什么?就是将多个物体公共点归纳出来,抽出像的部分。
封装(Encapsulation)
封装是面向对象的特征之一,是对象和类概念的主要特性。封装是把过程和数据包围起来,对数据的访问只能通过制定的方式。
在定义一个对象的特性的时候,有必要决定这些特性的可见性,即那些特性对外部是可见的,哪些特性用于表示内部状态。
通常,应禁止直接访问一个对象中数据的实际表示,而应通过操作接口来访问,这称之为隐藏信息。
信息隐藏是用户对封装性的认识,封装则为信息隐藏提供支持。
封装保证了模块具有较好的独立性,使用程序维护修改较为容易。对应用程序的修改仅限于类的内部,因而可以将应用程序修改带来的影响减少到最低限度。
继承(inheritance)
- 继承是一种联结类的层次模型,并且允许和支持类的重用,它提供了一种明确表述共性的方法。
- 新类继承了原始类后,心累就继承了原始类的特性,新类称为原始类的派生类(子类),而原始类称为新类的基类(父类)
- 派生类(子类)可以从它的基类(父类)那里继承方法和实例变量,并且派生类(子类)中可以修改或增加新的方法使之更合适特殊的需要,继承性很好的解决了软件的可重用性问题。比如说:所有的windows应用程序都有一个窗口,它们可以看做都是一个窗口类派生出来的。但是有的应用程序用于文字处理,有的应用程序用于绘图,这是由于派生出了不同的子类,各个子类添加了不同的特性。
多态(polymorphism)
多态性是指允许不同类的对象对同一消息作为响应。
多态性语言具有灵活、抽象、行为共享、代码共享的优势,很好的解决了应用程序函数同名问题。
相同类域的不同对象,调用相同方法,表现出不同的结果
从认识论角度考虑是先有对象后有类。对象是具体的事物。类是抽象的,是对对象的抽象。
从代码运行角度考虑是现有类后有对象。类是对象的模板。
2、类与对象的关系
类是一种抽象的数据类型,它是对某一类事物整体描述/定义,但是并不能代表某一个具体的事物。
例如:我们生活中所说的词语:动物、植物、手机、电脑等等。这些也都是抽象的概念,而不是指的摸一个具体的东西。
列如:Person类,Pet类,Car类等,这些类都是用来描述/定义某一类具体的事物应该具备的特点和行为
对象是抽象概念的具体实例
例如:张三就是人的一个具体实例,张三家的旺财就是狗的一个具体实例。能够体现出特点,展现出功能的是具体的实例,而不是一个抽象的概念。
示例
1 Student s = new Student(1L,"tom",20); 2 s.study(); 3 4 5 Car c = new Car(1,"BWM",500000); 6 c.run();
对象s就是student类的一个实例,对象c就是Car类的一个具体实例,能够使用的是具体实例,而不是类。
类知识给对象的创建提供了一个参考的模板而已
但是在Java中,没有类就没有对象,然而类有是根据具体的功能需求进行实际的分析,最终抽象出来的。
3、对象和引用的关系
引用"指向"对象
使用类类型、数组类型、接口类型声明出的变量,都可以指向对象,这种变量就是引用类型变量,简称引用。
在程序中,创建出对象后,直接使用并不方便,所以一般会用一个引用类型的变量去接收这个对象,这个就是所说的引用指向对象。
总结:对象和引用的关系,就如电视机和遥控器,风筝和先的关系一样。
方法回顾与加深
方法一定是定义在类中,属于类的成员
1、方法的定义
格式: 修饰符 返回值类型 方法名(参数列表)异常抛出类型{......}
1. 修饰符
public、static、abstract、final等等都是修饰符,一个方法可以有多个修饰符。例如程序入口main方法,就使用了public static这个两个修饰符
注:如果一个方法或者属性有多个修饰符,这多个修饰符是没有先后顺序的
2. 返回类型
方法执行完如果有要返回的数据,那么就要声明返回数据的类型,如果没有返回的数据,那么返回类型就必须写void
只有构造方法(构造器)不写任何返回类型也不写void
1 public String sayHello(){ 2 return "hello"; 3 } 4 5 6 public int max(int a,int b){ 7 return a>b?a:b; 8 } 9 10 11 public void print(String msg){ 12 System.out.println(msg); 13 }
思考:声明返回类型的方法中一定要出现return语句,那么没有返回类型(void)的方法中,能不能出现return语句?
注:break和return的区别
return语句的作用
- return从当前的方法中退出,返回到该调用的方法的语句处,进行执行。
- return返回一个值给调用该方法的语句,返回值的数据类型必须与方法的声明中的返回值的类型一致。
- return后面也可以不带参数,不带参数就是返回空,其实主要目的就是用于向终端函数执行,返回调用函数处。
break语句的作用
- break在循环体内,强行结束循环的执行,也就是结束整个循环过程,不在判断执行循环的条件是否成立,直接转向循环语句下面的语句。
- 当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、非静态方法
没有使用static修饰符修饰符方法,就是非静态方法
调用这种方法的时候,是“一定”要使用对象的。因为非静态方法时属于对象的(非静态属性也是一样的)
1 public class Student { 2 private double score=10.0d; 3 public static void main(String[] args) { 4 //对象 5 Student s = new Student(); 6 //非静态变量使用对象来访问 7 System.out.println(s.score); 8 } 9 }
2、静态方法
使用static修饰符修饰的方法,就是静态方法。
调用这种方法的时候,可以使用对象调用,也可以使用类来调用,但是推荐使用类进行调用,因为静态方法是属于类的(静态属性也是一样)
1 public class Student { 2 private static int age=10; 3 public static void main(String[] args) { 4 //对象 5 Student s = new Student(); 6 //静态变量可以使用类名 7 System.out.println(Student.age); 8 System.out.println(s.age); 9 } 10 }
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方法。静态方法不能调用非静态方法。
1 public static void a(){ 2 //b();报错 3 } 4 public void b(){ 5 a(); 6 }
另外:在同一个类中,静态方法内不能直接访问到类中的非静态属性。
总结:类中方法中的调用,两个方法都是静态或者非静态都可以互相调用,当一个方法时静态,一个方法时非静态的时候,非静态方法可以调用静态方法,反之不能
3、调用方法时的传参
1.形参和实参
1 public void test(int a){ 2 3 } 4 main: 5 int x = 1; 6 t.test(x);
参数列表中的a是方法test的形参(形式上的参数)
调用方法时的x是方法test的实参(实际上的参数)
注意:形参的名字和实参的名字都只是一个变量的名字,是可以随便写的,我们并不关心这个名字,而是关心变量的类型以及变量接收的值。
2、值传递和引用传递
调用方法进行传参时,分为值传递和引用传递两种
如果参数的类型是基本类型,那么就是值传递
如果参数的类型是引用类型,那么就是引用传递
值传递是实参把自己变量本身存的简单数值赋值给形参。
引用传递是实参把自己变量本身存的对象内存地址赋值给形参。
所以值传递和引用传递本质上是一回事,只不过传递的东西的意义不同而已
【值传递】
1 public class Test { 2 public static void changeNum(int a) { 3 a = 10; 4 } 5 6 public static void main(String[] args) { 7 int a = 1; 8 System.out.println("before: a = " + a); //1 9 changeNum(a); 10 System.out.println("after: a = "+a); //1 11 } 12 }
【引用传递】
1 public class Test { 2 public static void changName(Student student){ 3 student.name="dz"; 4 } 5 6 public static void main(String[] args) { 7 Student student = new Student(); 8 System.out.println("before name="+student.name);//before name=null 9 changName(student); 10 System.out.println("after name="+student.name);//after name=dz 11 } 12 } 13 class Student{ 14 String name; 15 }
4、this关键字
在类中,可以使用this关键字表示一些特殊的作用
1.this在类中的作用
【区分成员变量和局部变量】
1 public class student{ 2 private String name; 3 public void setName(String name){ 4 //this.name表示类中的属性name 5 this.name = name; 6 } 7 }
【调用类中的其他方法】
1 public class Student{ 2 private String name; 3 public void setName(String name){ 4 this.name = name; 5 } 6 public void print(){ 7 //表示调用当前类中的setName方法 8 this.setName("tom"); 9 } 10 }
注:默认情况下,setName("tom")和this.setName("tom")的效果是一样的
【调用类中其他构造器】
1 public class Student{ 2 private String name; 3 public Student(){ 4 //调用一个参数的构造器,并且参数的类型是string 5 this("tom"); 6 } 7 public Student(String name){ 8 this.name = name; 9 } 10 }
注:this的这种用法,只能在构造器中使用。普通的方法时不能用的。并且这句调用的代码只能出现在构造器中的第一句。
【示例】
1 public class Student{ 2 private String name; 3 public Student(){ 4 System.out.println("Hello"); 5 //编译报错,因为this("tom")不是构造器中的第一句 6 this("tom"); 7 } 8 public Student(String name){ 9 this.name = name; 10 } 11 }
2、this关键字在类中的意义
this在类中表示当前类将创建出的对象
【示例】
1 public class Student { 2 private String name; 3 4 public Student() { 5 System.out.println("this = " + this); 6 } 7 8 public static void main(String[] args) { 9 Student s = new Student(); 10 System.out.println("s = " + s); 11 } 12 }
运行看结果:
this和s打印的结果是一样的,那么其实也就是变量s是从对象的外部执行对象,而this是在对象的内部执行对象本身。
这样就能理解为什么this.name代表的是成员变量,this.setName("tom")代表的是调用成员方法,因为这两句代码从本质上讲,和在对象外部使用变量s来调用是一样的。
【this和s打印出来的内存地址是一样的,使用==比较的结果为true】
1 public class Student { 2 public Student getStudent() { 3 return this; 4 } 5 6 public static void main(String[] args) { 7 Student s1 = new Student(); 8 Student s2 = s1.getStudent(); 9 System.out.println(s1 == s2);//true 10 } 11 }
【类中的this是和s1相等还是和s2相等呢?】
1 public class Student { 2 private String name; 3 public void test(){ 4 System.out.println(this); 5 } 6 7 public static void main(String[] args) { 8 Student s1 = new Student(); 9 Student s2 = new Student(); 10 s1.test(); 11 s2.test(); 12 } 13 }
注:这句话是要这么来描述的,s1对象中的this和是相等,s2对象中的this和s2相等,因为类是模板,模板中写的this并不是只有一个,每个对象中都有一个属于自己的this,就是每个对象中都有一个属于自己的name属性一样。
创建与初始化对象
使用new关键字创建对象
使用new关键字创建时,除了分配内存空间之外,还会给创建好的对象进行默认初始化以及对类中构造器的调用
- 为对象分配内存空间,将对象的实例变量自动初始化默认值为0/null/false。(实例变量的隐式赋值)
- 如果代码中实例变量有显式赋值,那么就将之前的默认值覆盖掉。(之后可以通过例子看到这个现象)例如:显示赋值 private String name = "tom";
- 调用构造器
- 把对象内存地址赋值给变量。
构造器
类中的构造器也称为构造方法,是在进行创建对象的时候必须调用的。并且构造器有一下两个特点:
- 必须和类的名字相同
- 必须没有返回类型,也不能写void
构造器的作用
- 使用new创建对象的时候必须使用类的构造器
- 构造器中的代码执行后,可以给对象中的属性初始化赋值
【演示】
1 public class Student{ 2 private String name; 3 public Student(){ 4 name = "tom"; 5 } 6 }
构造器重载
除了无参构造器之外,很多时候我们还会使用有参构造器,在创建对象时候可以给属性赋值
【例子】
1 public class Student{ 2 private String name; 3 public Student{ 4 name = "tom"; 5 } 6 public Student(String name){ 7 this.name = name; 8 } 9 }
构造器之间的调用
使用this关键字,在一个构造器中可以调用另一个构造器的代码。
注意:this的这种用法不会产生新的对象,只是调用了构造器中的代码而已,一般情况下只有使用new关键字才会创建新对象。
【演示】
1 public class Student { 2 private String name; 3 public Student(){ 4 this(); 5 } 6 public Student(String name){ 7 this.name = name; 8 } 9 }
默认构造器
在Java中,即使我们在编写类的时候没有写构造器,那么在编译之后也会自动的添加一个无参构造器,这个无参构造器也被称为默认构造器
【示例】
1 public class Student{ 2 3 } 4 5 main: 6 //编译通过,因为有无参构造器 7 Student s = new Student();
但是,如果我们手动的编写了一个构造器,那么编译后就不会添加任何构造器了
【示例】
1 public class Student{ 2 private String name; 3 public Student(String name){ 4 this.name = name; 5 } 6 } 7 8 9 main: 10 //编译错误,因为没有无参构造器 11 Student s = new Student();
内存分析
Java程序运行的内存分析
栈 stack:
- 每个线程私有,不能实现线程间的共享
- 局部变量放置于栈中。
- 栈是由系统自动分配,速度快,栈是一个连续的内存空间
堆 heap:
- 放置new出来的对象
- 堆是一个不连续的内存空间,分配灵活,速度慢
方法区(也是堆)
- 被所有线程共享
- 用来存放程序中永远是不变或唯一的内容。(类代码信息、静态变量、字符串常量)
引用类型的概念
- java中,除了基本数据类型之外的其他类型称之为引用类型。
- java中的对象是通过引用来操作的。(引用:reference)引用指的就是对象的地址
属性(field或者叫成员变量)
- 属性用于定义该类或该类对象包含的数据或者说静态属性
- 属性作用范围是整个类体
- 属性的默认初始化
- 在定义成员变量时可以对其初始化,如果不对其初始化,Java使用默认的值对其初始化。(数值:0,0.0 char:u0000 boolean:false 所有引用类型:null)
- 属性定义格式 【修饰符】 属性类型 属性名 = 【默认值】
类的方法
方法是类和对象动态行为特征的抽象。方法很类似于面向过程中的函数。面向过程中,函数是最基本单位,整个程序有一个个函数调用组成;
在面向对象中,整个程序的基本单位是类,方法是从属于类或对象的。
方法定义格式:
1 【修饰符】 方法返回值类型 方法名(形参列表){ 2 3 //语句 4 }
java对象的创建和使用
- 必须使用new关键字创建对象 Person person = new Person();
- 使用对象(引用).成员变量来引用对象的成员变量 person.age
- 使用对象(引用).方法(参数列表)来调用对象的方法 setAge(23)
类中就是:静态的数据 动态的行为
封装
我们看电视,只需要按一下开关和换台就可以了,没有必要了解电视的内部结构。
制造厂家为了方便我们使用电视,把复杂的内部细节全部封装起来,只给我们暴露简单的接口,比如:电源开关
需要让用户知道的暴露出来,不需要让用户了解的全部隐藏,这就是封装
专业解释:我们程序设置要追求“高内聚,低耦合”。高内聚就是类的内部数据操作细节自己完成,不允许外部干涉,低耦合:仅暴露少量的方法给外部使用
1.封装的步骤
- 使用private修饰需要封装的成员变量
- 提供一个公共的方法设置或者访问私有属性
- 设置通过set方法,命名格式:set属性名();属性的首字母要大写
- 访问通过get方法,命名格式:get属性名();属性的首字母要大写
1 public class Student{ 2 public String name; 3 public void println(){ 4 System.out.println(this.name); 5 } 6 } 7 public class Test{ 8 public static void main(String[] args){ 9 Student s = new Student(); 10 s.name = "tom"; 11 } 12 }
在类中一般不会把数据直接暴露在外部,而使用private(私有)关键字把数据隐藏起来
【演示】
1 public class Student{ 2 private String name; 3 } 4 public class Test{ 5 public static void main(String[] args){ 6 Student s = new Student(); 7 //编译报错,在类的外部不能直接访问类中的私有成员 8 s.name = "tom"; 9 } 10 }
如果在类的外部需要访问这些私有属性,那么可以在类中提供对于的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()); 18 } 19 }
2.作用和意义
- 提高程序的安全性,保护数据
- 隐藏代码的实现细节
- 统一用户的调用接口
- 提高系统的可维护性
- 便于调用者使用
良好的封装,便于修改内部代码,提高可维护性
良好的封装,可以进行数据完整性检测,保证数据的有效性
3.方法重载
类中有多个方法,有着相同的方法名,但是方法的参数各不相同,这种情况被称为方法的重载。方法的重载可以提供方法调用的灵活性。
思考:HelloWorld中的System.out.println()方法,为什么可以把不同类型的参数传给这个方法?
方法重载必须满足以下条件
- 方法名必须项目
- 参数列表必须不同(参数的类型,个数,顺序的不同)
- 方法的返回值可以不同,也可以相同
1 public void test(Strig str){} 2 public void test(int a){} 3 4 public void test(Strig str,double d){} 5 public void test(Strig str){} 6 7 public void test(Strig str,double d){} 8 public void test(double d,Strig str){}
在Java中,判断一个类中的两个方法是否相同,主要参考两个方面:方法名字和参数列表
继承
现实世界中的继承无处不在。比如:
动物:哺乳动物,爬行动物
哺乳动物:灵长目,鲸目等
继承的本质是对某一批类的抽象,从而实现对现实世界更好的建模
为什么需要继承?继承的作用?
第一好处:继承的本质在于抽象。类是对对象的抽象,继承是对某一批类的抽象
第二好处:为了提高代码的复用性
extends的意思是“扩展”。子类是父类的扩展
Java中类只有单继承,没有多继承。接口可以多继承
1.继承
- 继承是类和类之间的一种关系。除此之外,类和类之间的关系还有依赖,组合,聚合等
- 继承关系的两个类,一个为子类(派生类),一个为父类(基类)。子类继承父类,使用关键字extends来表示
1 public class student extends Person{ 2 3 }
- 子类和父类之间,从意义上讲是is a的关系
1 student is a person 2 dog is a animal
- 类和类之间的继承是单继承
一个子类只能“直接”继承一个父类,就像是一个人只能有一个亲生父亲
一个父类可以被多个子类继承,就像一个父亲可以有多个孩子
Java中接口和接口之间,可以继承,并且是多继承
- 父类中的属性和方法可以被子类继承
子类中继承了父类中的属性和方法后,在子类中能不能直接使用这些属性和方法,是和这些属性和方法原有的修饰符(public,private,protected,default)相关的.
例如:
父类中的属性和方法使用public修饰,在子类中继承后可以直接使用
分类中的属性和方法使用private修饰,在子类中继承后不可以直接使用
父类中的构造器是不能被子类继承的,但是子类的构造器中,会隐式的调用父类中的无参构造器(默认使用super关键字)
2.Object类
java中的每一个类都是"直接"或者“间接”的继承Object类。所以每一个对象都和Object类有is a的关系。
从API文档中,可以看到任何一个类最上层的父类都是Object。
在Object类中,提供了一些方法被子类继承,那么就意味着,在java中,任何一个对象都可以继承调用这些继承过来的方法。
例如:toString方法,equals方法,getclass方法
Object类中的每一个方法以后都会使用到。
3.Super关键字
子类继承父类之后,在子类中可以使用this来表示访问或调用子类中的属性或方法,使用super就表示访问或调用父类中的属性和方法
1.super的使用
【访问父类中的属性】
1 public class Person{ 2 protected String name ='dz'; 3 } 4 public class Student extends Person{ 5 private String name = "dz1"; 6 public void test(String name){ 7 System.out.println(name); 8 System.out.println(tjhis.name); 9 System.out.println(super.name); 10 } 11 }
【调用父类中的方法】
1 public class Person{ 2 public void print(){ 3 System.out.println("Person") 4 } 5 } 6 public class Student extends Person{ 7 public void print(){ 8 System.out.println("Student") 9 } 10 public void test(){ 11 print(); 12 this.print(); 13 super.print(); 14 } 15 } 16
1212121