面向对象(上)

面向过程与面向对象

  • 面向过程:强调的是功能行为,以函数为最小单位,考虑怎么做。
  • 面向对象:强调具备了功能的对象,以类/对象为最小单位,考虑谁来做。

面向对象的三大特征

  • 封装 (Encapsulation)
  • 继承 (Inheritance)
  • 多态 (Polymorphism)

举例对比:人把大象装进冰箱。
1.面向过程:强调的是功能行为,以函数为最小单位,考虑怎么做。

  • 把冰箱门打开;
  • 抬起大象,塞进冰箱;
  • 把冰箱门关闭。

2.面向对象:强调具备了功能的对象,以类/对象为最小单位,考虑谁来做。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
人{
打开(冰箱){
冰箱.开开();
}

抬起(大象){
大象.进入(冰箱);
}

关闭(冰箱){
冰箱.闭合();
}

}
1
2
3
4
冰箱{
开开(){}
闭合(){}
}
1
2
3
4
5

大象{
进入(冰箱){
}
}

完成一个项目(或功能)的思路

  • 根据问题需要,选择问题所针对的现实世界中的实体
  • 从实体中寻找解决问题相关的属性和功能,这些属性和功能就形成了概念世界中的类
  • 把抽象的实体用计算机语言进行描述,形成计算机世界中类的定义。即借助某种程序语言,把类构造成计算机能够识别和处理的数据结构。
  • 类实例化成计算机世界中的对象。对象是计算机世界中解决问题的最终工具。

Java语言的基本元素:类和对象

面向对象中两个重要的概念

  • 类:对一类事物的描述,是抽象的、概念上的定义;
  • 对象:是实际存在的该类事物的每个个体,因而也称为实例(instance)。

    面向对象程序设计的重点是类的设计;
    设计类,就是设计类的成员。

二者的关系:对象,是由类new出来的,派生出来的。

面向对象思想落地实现的规则一

1.创建类,设计类的成员;
2.创建类的对象;
3.通过“对象.属性”或“对象.方法”调用对象的结构。

补充:几个概念的使用说明

  • 属性 = 成员变量 = field = 域、字段;
  • 方法 = 成员方法 = 函数 = method
  • 创建类的对象 = 类的实例化 = 实例化类。

对象的创建和使用

对象的创建与对象的内存解析

  • 堆(Heap),此内存区域的唯一目的就是存放对象实例,几乎所有的对象实例都在这里分配内存。这一点在Java虚拟机规范中的描述是:所有的对象实例以及数组都要在堆上分配。
  • 通常所说的栈(Stack),是指虚拟机栈。虚拟机栈用于存储局部变量等。局部变量表存放了编译期可知长度的各种基本数据类型(boolean、byte、char 、 short 、 int 、 float 、 long 、double)、对象引用(reference类型,它不等同于对象本身,是对象在堆内存的首地址)。 方法执行完,自动释放。
  • 方法区(Method Area),用于存储已被虚拟机加载的类信息、常量、静态变量、即时编译器编译后的代码等数据。

典型代码:

1
2
3
Person p1 = new Person();
Person p2 = new Person();
Person p3 = p1;//没有新创建一个对象,共用一个堆空间中的对象实体。

说明:
如果创建了一个类的多个对象,则每个对象都独立的拥有一套类的属性。(非static的)意味着:如果我们修改一个对象的属性a,则不影响另外一个对象属性a的值。

对象的内存的解析

对象数组的内存解析

匿名对象:我们创建的对象,没显式的赋给一个变量名。即为匿名对象

特点:匿名对象只能调用一次。
举例:

1
2
3
4
new Phone().sendEmail();
new Phone().playGame();
new Phone().price = 1999;
new Phone().showPrice();//0.0

应用场景:

1
2
3
4
5
6
7
8
9
10
11
PhoneMall mall = new PhoneMall();

//匿名对象的使用
mall.show(new Phone());
其中,
class PhoneMall{
public void show(Phone phone){
phone.sendEmail();
phone.playGame();
}
}

理解”万事万物皆对象”

1.在Java语言范畴中,我们都将功能、结构等封装到类中,通过类的实例化,来调用具体的功能结构。

  • Scanner,String等;
  • 文件:File
  • 网络资源:URL

2.涉及到Java语言与前端Html、后端的数据库交互时,前后端的结构在Java层面交互时,都体现为类、对象。

类的成员之一:属性(field)

变量的分类:成员变量与局部变量

  • 在方法体外,类体内声明的变量称为成员变量。
  • 在方法体内部声明的变量称为局部变量。

注意:二者在初始化值方面的异同:

  • 同:都有生命周期
  • 异:局部变量除形参外,均需显式初始化。

成员变量(属性)和局部变量的区别?

成员变量 局部变量
声明的位置 直接声明在类中 方法形参或内部、代码块内、构造器内等
修饰符 private、public、static、final等 不能用权限修饰符修饰,可以用final修饰
初始化值 有默认初始化值 没有默认初始化值,必须显式赋值,方可使用
内存加载位置 堆空间 或 静态域内 栈空间

成员变量与局部变量的内存位置

类的成员之二:方法(method)

无返回值 有返回值
无形参 void 方法名(){} 返回值的类型 方法名(){}
有形参 void 方法名(形参列表){} 返回值的类型 方法名(形参列表){}

注 意

  • 方法被调用一次,就会执行一次
  • 没有具体返回值的情况,返回值类型用关键字void表示,那么方法体中可以不必使用return语句。如果使用,仅用来结束方法。
  • 定义方法时,方法的结果应该返回给调用者,交由调用者处理。
  • 方法中只能调用方法或属性,不可以在方法内部定义方法。

再谈方法

方法的重载

重载的概念
在同一个类中,允许存在一个以上的同名方法,只要它们的参数个数或者参数类型不同即可。

重载的特点:
与返回值类型无关,只看参数列表,且参数列表必须不同。(参数个数或参数类型)。调用时,根据方法参数列表的不同来区别。
重载示例:

1
2
3
4
5
6
//返回两个整数的和
int add(int x,int y){return x+y;}
//返回三个整数的和
int add(int x,int y,int z){return x+y+z;}
//返回两个小数的和
double add(double x,double y){return x+y;}

可变形参的方法

JavaSE 5.0 中提供了Varargs(variable number of arguments)机制,允许直接定义能和多个实参相匹配的形参。从而,可以用一种更简单的方式,来传递个数可变的实参。

1
2
3
4
//JDK 5.0以前:采用数组形参来定义方法,传入多个同一类型变量
public static void test(int a ,String[] books);
//JDK5.0:采用可变个数形参来定义方法,传入多个同一类型变量
public static void test(int a ,String…books);

说明:

  1. 声明格式:方法名(参数的类型名 …参数名)
  2. 可变参数:方法参数部分指定类型的参数个数是可变多个:0个,1个或多个
  3. 可变个数形参的方法与同名的方法之间,彼此构成重载
  4. 可变参数方法的使用与方法参数部分使用数组是一致的
  5. 方法的参数部分有可变形参,需要放在形参声明的最后
  6. 在一个方法的形参位置,最多只能声明一个可变个数形参
    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
    public class Test {
    public static void main(String[] args) {
    Test to = new Test();
    //下面两次调用将执行第二个test方法
    to.test1();
    to.test1("aa" , "bb");
    //下面将执行第一个test方法
    to.test(new String[]{"aa"});
    }

    public void test(String[] msg){
    System.out.println("含字符串数组参数的test方法 ");
    }
    public void test1(String book){
    System.out.println("****与可变形参方法构成重载的test1方法****");
    }
    public void test1(String ... books){
    System.out.println("****形参长度可变的test1方法****");
    }
    }

    /*
    ****形参长度可变的test1方法****
    ****形参长度可变的test1方法****
    含字符串数组参数的test方法
    */

    方法参数的值传递机制

    方法,必须由其所在类或对象调用才有意义。若方法含有参数:
  • 形参:方法声明时的参数
  • 实参:方法调用时实际传给形参的参数值

Java的实参值如何传入方法呢?
Java里方法的参数传递方式只有一种:值传递。 即将实际参数值的副本(复制品)传入方法内,而参数本身不受影响。

  • 形参是基本数据类型:将实参基本数据类型变量的“数据值”传递给形参
  • 形参是引用数据类型:将实参引用数据类型变量的“地址值”传递给形参

基本数据类型的参数传递

1
2
3
4
5
6
7
8
9
10
11
12
13
public static void main(String[] args) {
int x = 5;
System.out.println("修改之前x = " + x);// 5
// x是实参
change(x);
System.out.println("修改之后x = " + x);// 5
}

public static void change(int x) {
System.out.println("change:修改之前x = " + x);
x = 3;
System.out.println("change:修改之后x = " + x);
}

引用数据类型的参数传递

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
public class Test {
public static void main(String[] args) {
Person obj = new Person();
obj.age = 5;
System.out.println("修改之前age = " + obj.age);// 5
// x是实参
change(obj);
System.out.println("修改之后age = " + obj.age);// 3
}
public static void change(Person obj) {
System.out.println("change:修改之前age = " + obj.age);
obj.age = 3;
System.out.println("change:修改之后age = " + obj.age);
}
}

class Person{
int age;
}

递归(recursion)方法

递归方法:一个方法体内调用它自身。

  • 方法递归包含了一种隐式的循环,它会重复执行某段代码,但这种重复执行无须循环控制。
  • 递归一定要向已知方向递归,否则这种递归就变成了无穷递归,类似于死循环。
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
// 例1:计算1-n之间所有自然数的和
public int getSum(int n) {// 3

if (n == 1) {
return 1;
} else {
return n + getSum(n - 1);
}

}

// 例2:计算1-n之间所有自然数的乘积:n!
public int getSum1(int n) {

if (n == 1) {
return 1;
} else {
return n * getSum1(n - 1);
}

}

//例3:已知有一个数列:f(0) = 1,f(1) = 4,f(n+2)=2*f(n+1) + f(n),
//其中n是大于0的整数,求f(10)的值。
public int f(int n){
if(n == 0){
return 1;
}else if(n == 1){
return 4;
}else{
// return f(n + 2) - 2 * f(n + 1);
return 2*f(n - 1) + f(n - 2);
}
}

面向对象特征之一:封装与隐藏

为什么需要封装?封装的作用和含义?

  • 高内聚 :类的内部数据操作细节自己完成,不允许外部干涉;
  • 低耦合 :仅对外暴露少量的方法用于使用。

信息的封装和隐藏

Java中通过将数据声明为私有的(private),再提供公共的(public)方法:getXxx()setXxx()实现对该属性的操作,以实现下述目的:

  • 隐藏一个类中不需要对外提供的实现细节;
  • 使用者只能通过事先定制好的方法来访问数据,可以方便地加入控制逻辑,限制对属性的不合理操作;
  • 便于修改,增强代码的可维护性;

四种访问权限修饰符

Java权限修饰符publicprotected、(缺省)、private置于类的成员定义前,用来限定对象对该类成员的访问权限。

修饰符 类内部 同一个包 不同包的子类 同一个工程
private Yes
(缺省) Yes Yes
protected Yes Yes Yes
public Yes Yes Yes Yes

对于class的权限修饰只可以用public和default(缺省)。

  • public类可以在任意地方被访问。
  • default类只可以被同一个包内部的类访问。

类的成员之三:构造器(构造方法)

构造器的特征

  • 它具有与类相同的名称。
  • 它不声明返回值类型。(与声明为void不同)。
  • 不能被staticfinalsynchronizedabstractnative修饰,不能有return语句返回值。

构造器的作用:创建对象;给对象进行初始化

  • 如:Order o = new Order(); Person p = new Person(“Peter”,15);
  • 如同我们规定每个“人”一出生就必须先洗澡,我们就可以在“人”的构造器中加入完成“洗澡”的程序代码,于是每个“人”一出生就会自动完成“洗澡”,程序就不必再在每个人刚出生时一个一个地告诉他们
    要“洗澡”了。

根据参数不同,构造器可以分为如下两类:

  • 隐式无参构造器(系统默认提供)
  • 显式定义一个或多个构造器(无参、有参)

注意:

  • Java语言中,每个类都至少有一个构造器
  • 默认构造器的修饰符与所属类的修饰符一致
  • 一旦显式定义了构造器,则系统不再提供默认构造器
  • 一个类可以创建多个重载的构造器
  • 父类的构造器不可被子类继承

构造器重载

构造器一般用来创建对象的同时初始化对象。如

1
2
3
4
5
class Person{
String name;
int age;
public Person(String n , int a){ name=n; age=a;}
}

构造器重载使得对象的创建更加灵活,方便创建各种不同的对象。构造器重载,参数列表必须不同

1
2
3
4
5
6
public class Person{
public Person(String name, int age, Date d) {this(name,age);…}
public Person(String name, int age) {…}
public Person(String name, Date d) {…}
public Person(){…}
}

构造器重载举例

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
public class Person {
private String name;
private int age;
private Date birthDate;
public Person(String n, int a, Date d) {
name = n;
age = a;
birthDate = d;
}
public Person(String n, int a) {
name = n;
age = a;
}
public Person(String n, Date d) {
name = n;
birthDate = d;
}
public Person(String n) {
name = n;
age = 30;
}
}

拓展知识:JavaBean

  • JavaBean是一种Java语言写成的可重用组件。
  • 所谓javaBean,是指符合如下标准的Java类:
    • 类是公共的
    • 有一个无参的公共的构造器
    • 有属性,且有对应的get、set方法
  • 用户可以使用JavaBean将功能、处理、值、数据库访问和其他任何可以用Java代码创造的对象进行打包,并且其他的开发者可以通过内部的JSP页面、Servlet、其他JavaBean、applet程序或者应用来使用这些对象。用户可以认为JavaBean提供了一种随时随地的复制和粘贴的功能,而不用关心任何改变。

JavaBean示例

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
public class JavaBean {
private String name; // 属性一般定义为private
private int age;
public JavaBean() {
}
public int getAge() {
return age;
}
public void setAge(int a) {
age = a;
}
public String getName() {
return name;
}
public void setName(String n) {
name = n;
}
}

拓展知识:UML类图

  • + 表示 public 类型, - 表示 private 类型,#表示protected类型;
  • 方法的写法:方法的类型(+、-) 方法名(参数名: 参数类型):返回值类型。

关键字:this的使用

this是什么?

  • 在Java中,this关键字比较难理解,它的作用和其词义很接近。
  • 它在方法内部使用,即这个方法所属对象的引用;
  • 它在构造器内部使用,表示该构造器正在初始化的对象。
  • this 可以调用类的属性、方法和构造器
  • 什么时候使用this关键字呢?
    • 当在方法内需要用到调用该方法的对象时,就用this
    • 具体的:我们可以用this来区分属性和局部变量。
    • 比如:this.name = name;

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
class Person{ // 定义Person类
String name;
Person(String name){
this.name = name;
}
public void getInfo(){
System.out.println("Person类 --> " + this.name) ;
}
public boolean compare(Person p){
return this.name==p.name;
}
}
public class PersonTest{
public static void main(String args[]){
Person per1 = new Person("张三") ;
Person per2 = new Person("李四") ;
per1.getInfo() ;
// 当前调用getInfo()方法的对象是per1
per2.getInfo() ;
// 当前调用getInfo()方法的对象是per2
boolean b = per1.compare(per2);
System.out.println(b) ;

} }

使用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
class Person{
// 定义Person类
private String name ;
private int age ;
public Person(){
// 无参构造器
System.out.println("新对象实例化") ;
}
public Person(String name){
this(); // 调用本类中的无参构造器
this.name = name ;
}
public Person(String name,int age){
this(name) ; // 调用有一个参数的构造器
this.age = age;
}
public String getInfo(){
return "姓名:" + name + ",年龄:" + age ;
}
}
public class PersonTest{
public static void main(String args[]){
Person per1 = new Person("张三") ;
Person per2 = new Person("李四") ;


} }

注意

  • 可以在类的构造器中使用”this(形参列表)”的方式,调用本类中重载的其他的构造器!
  • 明确:构造器中不能通过”this(形参列表)”的方式调用自身构造器
  • 如果一个类中声明了n个构造器,则最多有 n - 1个构造器中使用了”this(形参列表)”
  • “this(形参列表)”必须声明在类的构造器的首行!
  • 在类的一个构造器中,最多只能声明一个”this(形参列表)”

关键字:package、import的使用

关键字—package

  • package语句作为Java源文件的第一条语句,指明该文件中定义的类所在的包。(若缺省该语句,则指定为无名包)。它的格式为:package 顶层包名.子包名 ;

举例:pack1\pack2\PackageTest.java

1
2
3
4
5
6
package pack1.pack2; //指定类PackageTest属于包pack1.pack2
public class PackageTest{
public void display(){
System.out.println("in method display()");
}
}
  • 包对应于文件系统的目录,package语句中,用 “.” 来指明包(目录)的层次;
  • 包通常用小写单词标识。通常使用所在公司域名的倒置:com.atguigu.xxx

包的作用:
包帮助管理大型软件系统:将功能相近的类划分到同一个包中。比如:MVC的设计模式

  • 包可以包含类和子包,划分项目层次,便于管理
  • 解决类命名冲突的问题
  • 控制访问权限

例:某航运软件系统包括:一组域对象、GUI和reports子系统

MVC设计模式

MVC是常用的设计模式之一,将整个程序分为三个层次:视图模型层,控制器层,与数据模型层。这种将程序输入输出、数据处理,以及数据的展示分离开来的设计模式使程序结构变的灵活而且清晰,同时也描述了程序各个对象间的通信方式,降低了程序的耦合性。

模型层(model 主要处理数据)

  • 数据对象封装 model.bean/domain
  • 数据库操作类 model.dao
  • 数据库 model.db

控制层(controller 处理业务逻辑)

  • 应用界面相关controller.activity
  • 存放 fragment controller.fragment
  • 显示列表的适配器 controller.adapter
  • 服务相关的 controller.service
  • 抽取的基类 controller.base

JDK中主要的包介绍

1.java.lang—-包含一些Java语言的核心类,如String、Math、Integer、 System和Thread,提供常用功能
2.java.net—-包含执行与网络相关的操作的类和接口。
3.java.io—-包含能提供多种输入/输出功能的类。
4.java.util—-包含一些实用工具类,如定义系统特性、接口的集合框架类、使用与日期日历相关的函数。
5.java.text—-包含了一些java格式化相关的类
6.java.sql—-包含了java进行JDBC数据库编程的相关类/接口
7.java.awt—-包含了构成抽象窗口工具集(abstract window toolkits)的多个类,这些类被用来构建和管理应用程序的图形用户界面(GUI)。

关键字—import

为使用定义在不同包中的Java类,需用import语句来引入指定包层次下所需要的类
或全部类(.*)。import语句告诉编译器到哪里去寻找类。

语法格式:

  • import 包名. 类名;

应用举例:

1
2
3
4
5
6
7
import pack1.pack2.Test; //import pack1.pack2.*;表示引入pack1.pack2包中的所有结构
public class PackTest{
public static void main(String args[]){
Test t = new Test(); //Test类在pack1.pack2包中定义
t.display();
}
}

注意:

  1. 在源文件中使用import显式的导入指定包下的类或接口
  2. 声明在包的声明和类的声明之间。
  3. 如果需要导入多个类或接口,那么就并列显式多个import语句即可
  4. 举例:可以使用java.util.*的方式,一次性导入util包下所有的类或接口。
  5. 如果导入的类或接口是java.lang包下的,或者是当前包下的,则可以省略此import语句。
  6. 如果在代码中使用不同包下的同名的类。那么就需要使用类的全类名的方式指明调用的是哪个类。
  7. 如果已经导入java.a包下的类。那么如果需要使用a包的子包下的类的话,仍然需要导入。
  8. import static组合的使用:调用指定类或接口下的静态的属性或方法