java-3-面向对象-类-属性-构造器-this-UML图

[TOC]

java 面向对象

类(Class)和对象(Object)是面向对象的核心概念。

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

面向对象程序设计的重点是类的设计，类的设计， 其实就是类的成员的设计

创建Java自定义类

1. 定义类（考虑修饰符、类名）
2. 编写类的属性（考虑修饰符、属性类型、属性名、 初始化值）
3. 编写类的方法（考虑修饰符、返回值类型、方法名、形参等）

public class Animal {
public int legs;
public void eat(){
System.out.println(“Eating.”);
}
public viod move(){
System.out.println(“Move.”);
	}
}

对象的创建和使用

• 创建对象语法： 类名 对象名 = new 类名();
• 使用“对象名.对象成员”的方式访问对象成员（包括属性和方法）

public class Zoo{
public static void main(String args[]){
//创建对象
Animal xb=new Animal();
xb.legs=4;//访问属性
System.out.println(xb.legs);
xb.eat();//访问方法
xb.move();//访问方法
	}
}

说明：如果创建了一个类的多个对象，对于类中定义的属性，每个对象都拥有各自的一套副本，且互不干扰。

类的访问机制：

• 在一个类中的访问机制： 类中的方法可以直接访问类中的成员变量。（例外： static方法访问非static， 编译不通过。 ）
• 在不同类中的访问机制： 先创建要访问类的对象， 再用对象访问类中定义的成员。

对象的创建和使用：内存解析

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

匿名对象

• 我们也可以不定义对象的句柄，而直接调用这个对象的方法。这样的对象叫做匿名对象。
  • 如： new Person().shout();
• 使用情况
  • 如果对一个对象只需要进行一次方法调用，那么就可以使用匿名对象。
  • 我们经常将匿名对象作为实参传递给一个方法调用。

类的成员

属性

当一个对象被创建时，会对其中各种类型的成员变量自动进行初始化赋值

成员变量类型	初始值
byte	0
short	0
int	0
long	0L
float	0.0F
double	0.0
char	0 或写为:’\u0000’(表现为空)
boolean	false
引用类型	null

方 法(method)

什么是方法(method、函数):

• 方法是类或对象行为特征的抽象，用来完成某个功能操作。在某些语言中也称为函数或过程。
• 将功能封装为方法的目的是，可以实现代码重用，简化代码
• Java里的方法不能独立存在，所有的方法必须定义在类里

方法的声明格式：

修饰符 返回值类型 方法名（参数类型 形参1, 参数类型 形参2, ….）｛
	方法体程序代码
	return 返回值;
｝

其中：

• 修饰符：public,缺省,private, protected等

• 返回值类型：

  • 没有返回值： void。
  • 有返回值，声明出返回值的类型。与方法体中“return 返回值” 搭配使用
    方法名：属于标识符，命名时遵循标识符命名规则和规范，“见名知意”
    形参列表：可以包含零个，一 个或多个参数。多个参数时，中间用“,”隔开
    返回值：方法在执行完毕后返还给调用它的程序的数据。

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

方法的调用

• 方法通过方法名被调用，且只有被调用才会执行。
• 方法调用的过程分析

注 意：

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

方法的重载(overload)

重载的概念
在同一个类中，允许存在一个以上的同名方法，只要它们的==参数个数==或者==参数类型==不同即可。
重载的特点：
与返回值类型无关，只看参数列表，且参数列表必须不同。 (参数个数或参数类型)。调用时， 根据方法参数列表的不同来区别。
重载示例：

//返回两个整数的和
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;}

判 断：
与void show(int a,char b,double c){}构成重载的有：

void show(int x,char y,double z){} // no
int show(int a,double c,char b){} // yes
void show(int a,double c,char b){} // yes
boolean show(int c,char b){} // yes
void show(double c){} // yes
double show(int x,char y,double z){} // no
void shows(){double c} // no 

可变个数的形参

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

//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. 在一个方法的形参位置，最多只能声明一个可变个数形参

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方法****");
}
public static void main(String[] args){
TestOverload to = new TestOverload();
//下面两次调用将执行第二个test方法
to.test1();
to.test1("aa" , "bb");
//下面将执行第一个test方法
to.test(new String[]{"aa"});
}

方法参数的值传递机制

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

Java的实参值如何传入方法呢？
Java里方法的参数传递方式只有一种： ==值传递==。 即将实际参数值的副本（复制品）传入方法内，而参数本身不受影响。

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

基本数据类型的参数传递

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);
}

引用数据类型的参数传递

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);
}
// 其中Person类定义为：
class Person{
int age;
}

递归方法：

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

• 方法递归包含了一种隐式的循环，它会重复执行某段代码，但这种重复执行无须循环控制。

• 递归一定要向已知方向递归，否则这种递归就变成了无穷递归，类似于死循环。

public int sum(int num){
if(num == 1){
return 1;
}else{
return num + sum(num - 1);
	}
}

面向对象特征

封装和隐藏

• 我们程序设计追求“高内聚，低耦合”。
  • 高内聚 ：类的内部数据操作细节自己完成，不允许外部干涉；
  • 低耦合 ： 仅对外暴露少量的方法用于使用。
• 隐藏对象内部的复杂性，只对外公开简单的接口。便于外界调用，从而提高系统的可扩展性、可维护性。通俗的说， ==把该隐藏的隐藏起来，该暴露的暴露出来。 这就是封装性的设计思想。==

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

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

class Animal {
private int legs;// 将属性legs定义为private，只能被Animal类内部访问
public void setLegs(int i) { // 在这里定义方法 eat() 和 move()
if (i != 0 && i != 2 && i != 4) {
System.out.println("Wrong number of legs!");
return;
	}
legs = i;
}
public int getLegs() {
return legs;
	}
}
public class Zoo {
public static void main(String args[]) {
Animal xb = new Animal();
xb.setLegs(4); // xb.setLegs(-1000);
//xb.legs = -1000; // 非法
System.out.println(xb.getLegs());
	}
}

四种访问权限修饰符

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

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

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

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

构造器

构造器的特征

• 它具有与类相同的名称
• 它不声明返回值类型。（与声明为void不同）
• 不能被static、 final、 synchronized、 abstract、 native修饰，不能有return语句返回值

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

举 例：
创建Animal类的实例： Animal a = new Animal();调用构造器， 将legs初始化为4。

/** 语法格式：
修饰符 类名 (参数列表) {
初始化语句；
} */

public class Animal {
private int legs;
// 构造器
public Animal() {
legs = 4;
	}
public void setLegs(int i) {
legs = i;
	 }
public int getLegs() {
return legs;
 	}
}

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

• 隐式无参构造器（系统默认提供）

• 显式定义一个或多个构造器（无参、有参）

注 意：

• Java语言中，每个类都至少有一个构造器

• 默认构造器的修饰符与所属类的修饰符一致

• ==一旦显式定义了构造器， 则系统不再提供默认构造器==

• 一个类可以创建多个重载的构造器

• 父类的构造器不可被子类继承

构造器重载

构造器重载，参数列表必须不同

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示例

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类图

1. + 表示 public类型， -表示 private类型，#表示protected类型
2. 方法的写法:
   方法的类型(+、 -)方法名(参数名： 参数类型)：返回值类型

关键字： this的使用

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

class Person{ // 定义Person类
	private String name ;
	private int age ;
public Person(String name,int age){
    this.name = name ;
    this.age = age ; }
public void getInfo(){
S	ystem.out.println("姓名： " + name) ;
	this.speak();
	}
public void speak(){
	System.out.println(“年龄： ” + this.age);
	}
}

1. 在任意方法或构造器内，如果使用当前类的成员变量或成员方法可以在其前面添加this，增强程序的阅读性。不过，通常我们都习惯省略this。
2. 当形参与成员变量同名时，如果在方法内或构造器内需要使用成员变量，必须添加this来表明该变量是类的成员变量
3. 使用this访问属性和方法时，如果在本类中未找到，会从父类中查找

使用this调用本类的构造器

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 ;
	}
}

注意：

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

关键字： package、import的使用

package语句

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

// 举例： pack1\pack2\PackageTest.java
package pack1.pack2; //指定类PackageTest属于包pack1.pack2
public class PackageTest{
public void display(){
System.out.println("in method display()");
	}
}

• 包对应于文件系统的目录， package语句中，用 “.” 来指明包(目录)的层次；
• 包通常用小写单词标识。通常使用所在公司域名的倒置： com.atguigu.xxx

包的作用：

• 包帮助管理大型软件系统： 将功能相近的类划分到同一个包中。 比如： MVC的设计模式
• 包可以包含类和子包， 划分项目层次， 便于管理
• 解决类命名冲突的问题
• 控制访问权限

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)。 B/S C/S

MVC设计模式

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

模型层 model 主要处理数据
>数据对象封装 model.bean/domain
>数据库操作类 model.dao
>数据库 model.db

视图层 view 显示数据
>相关工具类 view.utils
>自定义view view.ui

控制层 controller 处理业务逻辑
>应用界面相关 controller.activity
>存放fragment controller.fragment
>显示列表的适配器 controller.adapter
>服务相关的 controller.service
>抽取的基类 controller.base

import

​ 为使用定义在不同包中的Java类，需用import语句来引入指定包层次下所需要的类或全部类(.)。 import语句告诉编译器到哪里去寻找类。
语法格式：
import 包名. 类名;
*应用举例：

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组合的使用：调用指定类或接口下的静态的属性或方法

参考：

尚硅谷_Java零基础教程-java入门必备-适合初学者的全套完整版教程(宋红康主讲)