Java 第四章 面向对象(上)
面向对象与面向过程的区别
面向过程:强调的是功能行为,以函数为最小单位,考虑怎么做
面向对象:强调具备了功能的对象,以类/对象为最小单位,考虑谁来做
理解“万事万物皆对象”
1.在Java语言范畴中,我们都能将功能、结构等封装到类中,通过类的实例化,来调用具体的功能结构
2.涉及到Java语言与前端HTML、后端的数据库交互时,前后端的结构在Java层面交互时,都体现为类、对象。
举例
Scanner,String等
文件:File
网络资源:URL
面向对象学习的三条主线:
- Java类及类的成员:属性、方法、构造器;代码块、内部类
- 三大特征:封装、继承、多态、(抽象)
- 其他关键字:this、super、final、abstract、interface、package、import
人
面向对象的两个要素
类(Class):对一类事物的描述,是抽象的、概念上的定义
对象(Object):实际存在的该类事物的每个个体,因而称为“实例”(instance)
面向对象程序设计的重点是类的设计,设计类,就是设计类的成员
一、设计类,其实就是设计类的成员
属性 = 成员变量 = field = 域、字段
方法 = 成员方法 = 函数 = method
创建类的对象 = 类的实例化 = 实例化类
二、类和对象的使用(面向对象思想落地的实现)
- 创建类,设计类的成员
- 创建类的对象
- 通过"对象.属性"或"对象.方法"调用对象的结构
public class person//1. 创建类,设计类的成员
{
String name;
int age=1;
boolean isMale;
//属性
void sleep()
{
System.out.println("Good Night,zzz!");
}
void eat()
{
System.out.println("Eating!");
}
void talk(String Language)
{
System.out.println("Talking in Language "+Language);
}
//方法
}
public class Person_Test
{
public static void main(String[] args)
{
person p1 = new person();//2.创建类的对象
//Scanner sc = new Scanner(System.in)
p1.name = "Tom";//3. 通过"对象.属性"或"对象.方法"调用对象的结构
p1.age = 18;
p1.isMale = true;
System.out.println(p1.name);
p1.eat();
p1.sleep();
p1.talk("English");
}
}
三、如果创建了一个类的多个对象,则每个对象都独立的拥有一套类的属性(非static的)
意味着:如果我们修改一个对象的属性a,则不影响另外一个对象属性a的值。
person p2 = p1;
p2.age = 20;
System.out.println(p1.age);//将p1变量保存的对象地址赋给p2,
//导致p1和p2指向了堆空间中同一个实体对象
四、对象的内存解析
虚拟机栈,即为平时提到的栈结构。我们将局部变量存储在栈结构中
堆,我们将new出来的结构加载在堆空间中,对象的属性(非static的)加载在堆空间中
方法区:类的加载信息、常量池、静态域
对象数组的内存解析:
四、类中属性的使用
属性(成员变量) VS 局部变量
1.相同点:
①定义变量的格式:数据类型 变量名 = 变量值
②先声明,后使用
③变量都有其对应的作用域
2.不同点:
①在类中声明的位置的不同:属性直接定义在类的一对{ }内;局部变量声明在方法内、方法形参、代码块内、构造器形参、构造器内部的变量
②关于权限修饰符的不同:属性在声明时,指明其权限,使用权限修饰符
常用权限修饰符:private、public、protected、缺省 —>封装性
目前,声明属性时使用缺省即可。
局部变量:不可以使用权限修饰符
③默认初始化值的情况:
属性:类的属性,根据其类型,都有默认初始化值。
整型(byte、short、int、long):0
浮点型(float、double):0.0
字符型(char):0(或’\u0000’)
布尔型(boolean):false
引用数据类型(类、接口、数组):null
局部变量:没有默认初始化值。意味着,在调用前一定要显式赋值。特别的,形参在调用时,赋值即可。
④在内存中加载的位置不同,属性(非static)加载到堆空间中;局部变量加载到栈空间。
五、类中方法的声明和使用
方法:描述类应该具有的功能。
比如:
Math类:sqrt()、random()…
Scanner类:nextXxx()…
Arrays类:sort()、binarySearch()、toString()、equals()…
方法的声明:
权限修饰符 返回值类型 方法名(形参列表)
{
方法体
}
说明:
①关于权限修饰符:private、public、protected、缺省
②返回值类型:有返回值 VS 无返回值
有返回值:在声明方法时,指定返回值的类型。同时在方法中,需要使用return 关键字来返回指定类型的变量或常量。
无返回值:在声明方法时,使用void来表示。提前结束用return ;
③方法名:属于标识符,遵循标识符的规则和规范,“见名知意”
④形参列表:方法可以声明0个,1个,或多个形参。
格式:数据类型1 形参1,数据类型2 形参2,…
⑤方法的使用中,可以调用当前类的属性或方法。特殊的,方法A中调用了方法A,称为递归
⑥方法中,不可以定义方法
六、匿名对象的使用
new person().sleep();
new person().eat();//匿名对象,二者是截然不同的对象
new Phone().price = 1999;
new Phone().ShowPrice();//double 0.0
1.理解:创建的对象,没有显式的赋给一个变量名。即为匿名对象
2.特征:匿名对象只能调用一次
3.使用:
public class phoneFactory
{
public void show(phone p1)
{
p1.playGame();
p1.sentEmail();
}
public static void main(String[] args)
{
phoneFactory f1 = new phoneFactory();
f1.show(new phone());//匿名
}
}
七、再谈方法
方法的重载(OverLoad)
1.概念:在同一个类中,允许存在一个以上的同名方法,只要让它们的参数个数或参数类型不同即可
2.特点:与返回值类型无关,只看参数列表,且参数列表必须不同。调用时,根据方法参数列表的不同来区别
3.示例
public class OverLoad
{
//如下的四个方法构成了重载
public int getSum(int m,int n)
{
return m+n;
}
private int getSum(int m)
{
return 1;
}
public double getSum(int m,double n)
{
return m+n;
}
protected double getSum(double a,int b)
{
return a+b;
}
}
4.在通过对象调用方法时,如何确定某一个指定的方法:
方法名---->参数列表
可变个数形参的方法
1.jdk5.0新增的内容
2.具体使用:
①格式:数据类型 … 变量名
②参数可以是0个、1个、多个
③可变个数形参的方法与本类中方法名相同,形参不同的方法之间构成重载
④可变个数形参的方法与本类中方法名相同,形参类型也相同的数组之间不构成重载
⑤可变个数形参在方法的形参中,必须声明在末尾
⑥可变个数形参在方法的形参中,最多只能声明一个可变形参
public class MethodArgs
{
public void show(int i)
{
System.out.println(i);
}
public void show(String s)
{
System.out.println("show(String)");
}
public void show(String ...strings)
{
System.out.println("String ...strings");
}
public void show(String[] strings)
{
}//错误!不构成重载
public void show(String ...strs,int i)
{
}//错误!可变形参必须放在列表末尾
public static void main(String[] args) {
MethodArgs MA = new MethodArgs();
MA.show("AAA","BBB");
MA.show();
MA.show(new String[] strs{"AA","BB","CC"});
MA.show("123");//优先考虑show(String)
MA.show(1);
}
}
方法参数的值传递机制
如果参数是基本数据类型,此时实参赋给形参的是实参真实存储的数据值
如果参数是引用数据类型,此时实参赋给形参的是实参存储数据的地址值
推广:
如果参数是基本数据类型,此时赋值的是变量所保存的数据值。
如果变量是引用数据类型,此时赋值的是变量所保存的数据的地址值。
练习:
public static void method1(int a,int b)
{
a = a*10;
b = b*20;
System.out.println("a="+a);
System.out.println("b="+b);
System.exit(0);
}
八、面向对象特征之一:封装和隐藏
设计程序追求“高内聚,低耦合”。
高内聚:类的内部数据操作细节由自己完成,不允许外部干涉;
低耦合:仅对外暴露少量的方法用于使用。
通俗的讲,就是把该隐藏的隐藏起来,该暴露的暴露出来,这就是封装的设计思想。
封装性的体现
将类的属性xxx私有化(private),同时提供公共的(public)方法来获取(getxxx)和设置(setxxx)
封装性的体现,需要权限修饰符来配合
1.四种权限(从小到大):private、缺省、protected、public
2.四种权限可以用来修饰类及类的内部结构:属性、方法、构造器、内部类
修饰类只能用缺省和public
Java提供四种权限修饰符来修饰类及类的内部结构,体现类及类的内部结构在被调用时的可见性的大小。
public class seal//同一个类下
{
public int member_public;
private int member_private;
int member_default;
public static void main(String[] args) {
seal s = new seal();
s.member_default = 1;
s.member_private = 1;
s.member_public = 1;
}
}
public class SealTest//同一个包下的不同类
{
public static void main(String[] args) {
seal s = new seal();
s.member_public = 1;
s.member_default = 1;
s.member_private = 1;//'member_private' 在 'com.package1.seal' 中具有 private 访问权限
}
}
package com.zjq.java;//同一个工程下的不同包
import com.package1.seal;
public class Seal_Test
{
public static void main(String[] args) {
seal s = new seal();
s.member_public = 1;
s.member_default = 1;//'member_default' 在 'com.package1.seal' 中不为 public。无法从外部包访问
s.member_private = 1;//'member_private' 在 'com.package1.seal' 中具有 private 访问权限
}
}
类的结构之三:构造器(或构造方法、constructor)的使用
1.构造器的作用:创建对象(创建类的对象:new + 构造器)、给对象进行初始化
2.定义构造器的格式:权限修饰符 类名(形参列表)
3.一个类中定义的多个构造器,彼此构成重载
4.一旦显式的定义了类的构造器后,系统不再提供默认的空参构造器
5.一个类中,至少存在一个构造器
6.构造器的权限与类的权限相同
public person()
{
System.out.println("person()...");
}
public person(String name)
{
this.name = name;
}
public person(String name,int age)
{
this.name = name;
this.setAge(age);
}
总结:属性赋值的先后顺序
默认初始化——显式初始化——构造器初始化——通过“对象.方法”或“对象.属性”的方式赋值
九、JavaBean介绍
JavaBean是一种Java语言写成的可重用组件。
所谓JavaBean,是指符合如下标准的Java类:
1.类是公共的 2.有一个无参的公共构造器 3.有属性,且有对应的get、set方法
十、UML类图介绍
十一、关键字——this
1.this可以用来修饰:属性、方法、构造器
2.this修饰属性和方法:this理解为当前对象 或 当前正在创建的对象
在类的方法中,我们可以使用“this.属性/方法”的方式,调用当前对象属性或方法。但是,通常情况下,我们都选择省略“this.”。特殊情况下,如果方法的形参和类的属性同名时,我们必须显式的使用“this.变量”的方式,表明此变量是属性,而不是形参。
3.this调用构造器:
在类的构造器中,可以显式的使用“this(形参列表)”方式,调用本类中指定的其他构造器,不能通过this(形参列表)方式调用自己。如果一个类中有n个构造器,则最多有n-1个构造器中使用了"this(形参列表)"
4.规定:“this(形参列表)”必须声明在当前构造器的首行
5.构造器内部,最多只能声明一个“this(形参列表)”
//this在方法中的使用
public void setAge(int age)
{
if(age>0&&age<=150)
this.age = age;
else throw new RuntimeException("The scale of age must be 1-150!");
}
public int getAge()
{
return this.age;
}
//this在构造器中的使用
public person(String name)
{
this.name = name;
}
public person(String name,int age)
{
this(age);
this.name = name;
}
十二、package关键字的使用
1.为了更好的实现项目中类的管理,提供包的概念
2.使用package声明类或接口所属的包,声明在源文件的首行
3.包,属于标识符,遵循标识符的命名规则、规范、“见名知意”
4.每“.”一次,就代表一层文件目录
5.同一个包下,不能命名同名的接口、类,不同的包下可以命名同名的接口、类。
十三、import关键字的使用
1.在源文件中显式的使用import结构导入指定包下的类、接口
2.声明在包的声明和类的声明之间
3.如果需要导入多个结构,则并列写出即可
4.可以使用“xxx.*”的方式,表示可以导入xxx包下的所有结构
5.如果使用的类或接口是java.lang包下定义的,则可以省略不写