包子学系列——Java基础第四章_面向对象编程（上）
第四章 面向对象编程（上）
-
Java类及类的成员：属性、方法、构造器；代码块、内部类
-
面向对象的大特征：封装性、继承性、多态性、(抽象性)
-
其它关键字：this、super、static、final、abstract、interface、package、import等
面向过程与面向对象
- 面向过程：强调的是功能行为，以函数为最小单位，考虑怎么做。
- 面向对象：强调具备了功能的对象，以类/对象为最小单位，考虑谁来做。
例子：把大象装进冰箱
类与对象
类(Class)和对象(Object)是面向对象的核心概念。
- 类是对一类事物的描述，是抽象的、概念上的定义
- 对象是实际存在的该类事物的每个个体，因而也称为实例(instance)。
- 比如
类： 人
对象：乔布斯、雷军、小明
面向对象程序设计的重点是类的设计
类的设计，其实就是类的成员的设计
- 类的成员方法和类的成员变量
- 又叫
行为和属性 Mehtod和Field
属性 = 成员变量 = field = 域、字段
方法 = 成员方法 = 函数 = method
创建类的对象 = 类的实例化 = 实例化类
两者的关系
对象，是由类new出来的，派生出来的。
对象的创建和使用
创建对象语法： 类名 对象名 = new 类名();
使用“对象名.对象成员”的方式访问对象成员（包括属性和方法）
我new好多个呢？每个对象是独立的哦
Person p1 = new Person();
Person p2 = new Person();
Person p3 = p1;//没有新创建一个对象，共用一个堆空间中的对象实体。
这里对象p1和p2是独立，不相关的，虽然它们都是抽象类Person的实例
如果创建了一个类的多个对象，则每个对象都独立的拥有一套类的属性。（非static的）意味着：如果我们修改一个对象的属性a，则不影响另外一个对象属性a的值。
内存解析
匿名对象
我们创建的对象，没显式的赋给一个变量名。即为匿名对象
特点：匿名对象只能调用一次。
new Phone().sendEmail();
new Phone().playGame();
new Phone().price = 1999;
new Phone().showPrice();//0.0
使用场景
-
如果对一个对象只需要进行一次方法调用，那么就可以使用匿名对象。
-
我们经常将匿名对象作为实参传递给一个方法调用。
类的结构一：属性
属性 vs 局部变量
1.相同点：
* 1.1 定义变量的格式：数据类型 变量名 = 变量值
* 1.2 先声明，后使用
* 1.3 变量都其对应的作用域
2.不同点：
2.1 在类中声明的位置的不同
* 属性：直接定义在类的一对{}内
* 局部变量：声明在方法内、方法形参、代码块内、构造器形参、构造器内部的变量
*
* 2.2 关于权限修饰符的不同
* 属性：可以在声明属性时，指明其权限，使用权限修饰符。
* 常用的权限修饰符：private、public、缺省、protected --->封装性
* 目前，大家声明属性时，都使用缺省就可以了。
* 局部变量：不可以使用权限修饰符。
*
* 2.3 默认初始化值的情况：
* 属性：类的属性，根据其类型，都默认初始化值。
* 整型（byte、short、int、long：0）
* 浮点型（float、double：0.0）
* 字符型（char：0 （或'\u0000'））
* 布尔型（boolean：false）
*
* 引用数据类型（类、数组、接口：null）
*
* 局部变量：没默认初始化值。
* 意味着，我们在调用局部变量之前，一定要显式赋值。
* 特别地：形参在调用时，我们赋值即可。
*
* 2.4 在内存中加载的位置：
* 属性：加载到堆空间中 （非static）
* 局部变量：加载到栈空间
| 成员变量 | 局部变量 | |
|---|---|---|
| 声明的位置 | 直接声明在类中 | 方法形参或内部、代码块内、构造器内等 |
| 修饰符 | private、public、static、final等 | 不能用权限修饰符修饰，可以用final修饰 |
| 初始化值 | 有默认初始化值 | 没有默认初始化值，必须显式赋值，方可使用 |
| 内存加载位置 | 堆空间 或 静态域内(static) | 栈空间 |
类的结构二：方法
- Java里的方法不能独立存在，所有的方法必须定义在类里。
- 方法是类或对象行为特征的抽象，用来完成某个功能操作。在某些语言中 也称为函数或过程。
public class Person{
private int age;
public int getAge() { //声明方法getAge()
return age;
}
public void setAge(int i) { //声明方法setAge
age = i; //将参数i的值赋给类的成员变量age
}
方法的声明
修饰符 返回值类型 方法名（参数类型 形参1, 参数类型 形参2, ….）｛
方法体程序代码
return 返回值;
｝
方法的调用
方法通过方法名被调用，且只有被调用才会执行
Person p = new Person();
p.say(); //调用say， 假设我们定义了一个Person类，有一个say方法
注意
- 方法被调用一次，就会执行一次
- 没有具体返回值的情况，返回值类型用关键字
void表示，那么方法体中可以不必使用return语句。如果使用，仅用来结束方法 - 方法中只能调用方法或属性，不可以在方法内部定义方法。
方法的重载
定义：在同一个类中，允许存在一个以上的同名方法，只要它们的参数个数或者参数类型不同即可。
重载的关键：只看参数列表和方法名，且参数列表必须不同,根据方法参数列表的不同来区别,不看返回值类型
例子
//返回两个整数的和
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;}
public void getSum(int i,int j){
System.out.println("1");
}
public void getSum(double d1,double d2){
System.out.println("2");
}
public void getSum(String s ,int i){
System.out.println("3");
}
public void getSum(int i,String s){
System.out.println("4");
}
使用重载方法，可以为编程带来方便。
总结："两同一不同":
- 同一个类、相同方法名，
- 参数列表不同：参数个数不同，参数类型不同“
可变参数
//JDK 5.0以前：采用数组形参来定义方法，传入多个同一类型变量
public static void test(int a ,String[] books);
//JDK5.0：采用可变个数形参来定义方法，传入多个同一类型变量
public static void test(int a ,String…books);
-
声明格式：
方法名(参数的类型名 ...参数名) -
可变参数：方法参数部分指定类型的参数个数是可变多个：0个，1个或多个
-
可变个数形参的方法与同名的方法之间，彼此构成重载
-
方法的参数部分有可变形参，需要放在形参声明的最后
-
在一个方法的形参位置，最多只能声明一个可变个数形参
例子
public void show(int i){
}
public void show(String s){
System.out.println("show(String)");
}
public void show(String ... strs){
System.out.println("show(String ... strs)");
for(int i = 0;i < strs.length;i++){
System.out.println(strs[i]); //取可变参数
}
}
//不能与上一个方法同时存在
// public void show(String[] strs){
//
// }
//调用
test.show("hello");
test.show("hello","world");
test.show();
test.show(new String[]{"AA","BB","CC"});
*Java的值传递机制
Java里方法的参数传递方式只有一种：值传递。 即将实际参数值的副本 （复制品）传入方法内，而参数本身不受影响
- 形参是基本数据类型：将实参基本数据类型变量的“数据值”传递给形参
- 形参是引用数据类型：将实参引用数据类型变量的“地址值”传递给形参
System.out.println("***********基本数据类型：****************");
int m = 10;
int n = m;
System.out.println("m = " + m + ", n = " + n);
//ans: m = 10, n = 10
n = 20;
System.out.println("m = " + m + ", n = " + n);
//ans: m = 10, n = 20
System.out.println("***********引用数据类型：****************");
Order o1 = new Order();
o1.orderId = 1001;
Order o2 = o1;//赋值以后，o1和o2的地址值相同，都指向了堆空间中同一个对象实体。
System.out.println("o1.orderId = " + o1.orderId + ",o2.orderId = " +o2.orderId);
//ans: o1.orderId = 1001,o2.orderId = 1001
o2.orderId = 1002;
System.out.println("o1.orderId = " + o1.orderId + ",o2.orderId = " +o2.orderId);
//ans: o1.orderId = 1002,o2.orderId = 1002
class Order{
int orderId;
}
例子
面向对象的特征一：封装性
隐藏对象内部的复杂性，只对外公开简单的接口。便于外界调用，从而提高系统的可扩展性、可维护性。通俗的说，把该隐藏的隐藏起来，该暴露的暴露出来。这就是封装性的设计思想。
追求：高内聚，低耦合
- 高内聚 ：类的内部数据操作细节自己完成，不允许外部干涉；
- 低耦合 ：仅对外暴露少量的方法用于使用。
Java中通过将数据声明为私有的(private)，再提供公共的（public） 方法:getXxx()和setXxx()实现对该属性的操作，
private double radius;
public void setRadius(double radius){
this.radius = radius;
}
public double getRadius(){
return radius;
}
封装性的几种体现
-
体现一：将类的属性xxx私化(private),同时，提供公共的(public)方法来获取(getXxx)和设置(setXxx)此属性的值
-
体现二：不对外暴露的私有的方法
-
体现三：单例模式（将构造器私有化）
-
体现四：如果不希望类在包外被调用，可以将类设置为缺省的。
四种权限修饰符
权限从小到大顺序为：private < 缺省 < protected < public
4种权限都可以用来修饰类的内部结构：属性、方法、构造器、内部类
修饰类的话，只能使用：缺省、public, 注意（private 可以用来修饰内部私有类，类种类）
类的结构三：构造器
构造器的作用
-
创建对象
-
初始化对象的信息
构造器的特征
- 它具有与类相同的名称
- 不能被static、final、synchronized、abstract、native修饰，不能有 return语句返回值
- 它不声明返回值类型。（与声明为void不同） 直接不写
Order o = new Order(); Person p = new Person(“Peter”,15);
一个类中，至少会有一个构造器。
一个类中定义的多个构造器，彼此构成重载
一旦我们显式的定义了类的构造器之后，系统就不再提供默认的空参构造器
你不写的化，默认一个无参构造器
例子
//构造器
public Person(){
System.out.println("Person().....");
}
public Person(String n){
name = n;
}
public Person(String n,int a){
name = n;
age = a;
}
属性赋值先后
① 默认初始化
② 显式初始化
③ 构造器中初始化
④ 通过"对象.方法" 或 "对象.属性"的方式，赋值
以上操作的先后顺序：① - ② - ③ - ④
JavaBean
有的地方也叫POJO
所谓JavaBean，是指符合如下标准的Java类：
- 类是公共的
- 一个无参的公共的构造器
- 属性，且对应的get、set方法
例子
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;
}
}
JavaBean的优势？
用户可以使用JavaBean将功能、处理、值、数据库访问和其他任何可以 用Java代码创造的对象进行打包，并且其他的开发者可以通过内部的JSP 页面、Servlet、其他JavaBean、applet程序或者应用来使用这些对象。用 户可以认为JavaBean提供了一种随时随地的复制和粘贴的功能，而不用关 心任何改变。
UML图
this关键字
可以调用的结构：属性、方法；构造器
- 它在方法内部使用，即这个方法所属对象的引用
- 它在构造器内部使用，表示该构造器正在初始化的对象
使用this，调用属性、方法
public void getInfo(){
System.out.println("姓名：" + name) ;
this.speak();
}
当形参与成员变量同名时， 如果在方法内或构造器内需要 使用成员变量，必须添加this来 表明该变量是类的成员变量
public boolean compare(Person p){
return this.name==p.name;
}
this与构造器
public Person(){ // 无参构造器
System.out.println("新对象实例化") ;
}
public Person(String name){
this(); // 调用本类中的无参构造器
this.name = name ;
}
public Person(String name,int age){
this(name) ; // 调用有一个参数的构造器
this.age = age;
}
-
在构造器中用
this调用别的构造器 -
如果一个类中声明了n个构造器，则最多有 n - 1个构造器中使用了 "this(形参列表)"
-
this(形参列表)"必须声明在类的构造器的首行！
-
在类的一个构造器中，最多只能声明一个"this(形参列表)"
package/import关键字
-
为了更好的实现项目中类的管理，提供包的概念
-
使用
package声明类或接口所属的包，声明在源文件的首行 -
包，属于标识符，遵循标识符的命名规则、规范(xxxyyyzzz)、“见名知意”
-
每
.一次，就代表一层文件目录。
package pack1.pack2; //指定类PackageTest属于包pack1.pack2
public class PackageTest{
public void display(){
System.out.println("in method display()");
}
}
包的作用
-
包帮助管理大型软件系统：将功能相近的类划分到同一个包中。比如：MVC的设计模式
-
包可以包含类和子包，划分项目层次，便于管理
-
解决类命名冲突的问题
-
控制访问权限
JDK中主要的包
import的使用
为使用定义在不同包中的Java类，需用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. 如果需要导入多个结构，则并列写出即可
* 4. 可以使用"xxx.*"的方式，表示可以导入xxx包下的所结构
* 5. 如果使用的类或接口是java.lang包下定义的，则可以省略import结构
* 6. 如果使用的类或接口是本包下定义的，则可以省略import结构
* 7. 如果在源文件中，使用了不同包下的同名的类，则必须至少一个类需要以全类名的方式显示。
* 8. 使用"xxx.*"方式表明可以调用xxx包下的所结构。但是如果使用的是xxx子包下的结构，则仍需要显式导入
* 9. import static:导入指定类或接口中的静态结构:属性或方法。
浙公网安备 33010602011771号