目录
一、面向对象思想
1.1 概述
Java语言是一种面向对象的程序设计语言,而面向对象思想是一种程序设计思想,我们在面向对象思想的指引下, 使用Java语言去设计、开发计算机程序。 这里的对象泛指现实中一切事物,每种事物都具备自己的属性和行为。面向对象思想就是在计算机程序设计过程中,参照现实中事物,将事物的属性特征、行为特征抽象出来,描述成计算机事件的设计思想。 它区别于面向过程思想,强调的是通过调用对象的行为来实现功能,而不是自己一步一步的去操作实现。
1.2 举例
洗衣服:
- 面向过程: 把衣服脱下来–>找一个盆–>放点洗衣粉–>加点水–>浸泡10分钟–>揉一揉–>清洗衣服–>拧干–>晾起来
- 面向对象: 把衣服脱下来–>打开全自动洗衣机–>扔衣服–>按钮–>晾起来
区别:
C语言是面向过程的,关注的是过程,分析出求解问题的步骤,通过函数调用逐步解决问题。
JAVA是基于面向对象的,关注的是对象,将一件事情拆分成不同的对象,靠对象之间的交互完成。
- 面向过程: 强调步骤,注重的是过程,在整个过程中所涉及的行为,就是功能。
- 面向对象: 强调对象,这里的对象就是洗衣机,也就是参与过程所涉及到的主体。是通过逻辑将一个个功能实现连接起来。
1.3 面向对象设计
面向对象设计把握一个重要的经验:谁拥有数据,谁对外提供操作这些数据(私有)的方法!
(被动的一方是数据的拥有者,主动的一方是执行者)
开发时:找对象,建对象,用对象,并维护对象之间的关系。
特点
面向对象思想是一种更符合我们思考习惯的思想,它可以将复杂的事情简单化,并将我们从执行者变成了指挥者。 面向对象的语言中,包含了几种基本特征,即封装、继承、多态和组合。
二、类和对象
什么是类
- 类: 是一组相关属性和行为的集合。可以看成是一类事物的模板,使用事物的属性特征和行为特征来描述该类事物。
现实中,描述一类事物:
- 属性: 就是该事物的状态信息。
- 行为: 就是该事物能够做什么。
什么是对象
- 对象: 是一类事物的具体体现。对象是类的一个实例(对象并不是找个女朋友),必然具备该类事物的属性和行为。
类与对象的关系
- 类是对一类事物的描述,是抽象的。
- 对象是一类事物的实例,是具体的。
- 类是对象的模板,对象是类的实体。
2.1 类的定义
声明一个类就是创建一个新的数据类型,而类在 Java 中属于引用类型, Java 使用关键字 class 来声明类。我们来看以下简单的声明一个类。
基本语法
// 创建类
class <class_name>{
field;//成员属性
method;//成员方法
}
// 实例化对象
<class_name> <对象名> = new <class_name>();
class为定义类的关键字,ClassName为类的名字,{}中为类的主体。
类中的元素称为:成员属性。
类中的函数称为:成员方法。
代码示例:
class Person {
public int age; //成员属性 实例变量
public String name;
public String sex;
public void eat() { //成员方法
System.out.println("吃饭!");
}
public void sleep() {
System.out.println("睡觉!");
}
}
2.2 对象的使用
对象的使用格式
创建对象:
类名 对象名 = new 类名();
使用对象访问类中的成员:
对象名.成员变量;
对象名.成员方法();
代码示例:
class Person {
public int age; //成员属性 实例变量
public String name;
public String sex;
public void eat() { //成员方法
System.out.println("吃饭!");
}
public void sleep() {
System.out.println("睡觉!");
}
}
public class Main{
public static void main(String[] args) {
Person person = new Person(); //通过new实例化对象
person.eat(); //成员方法调用需要通过对象的引用调用
person.sleep();
//产生对象 实例化对象
Person person2 = new Person();
Person person3 = new Person();
}
}
注意事项
- new 关键字用于创建一个对象的实例。
- 使用 . 来访问对象中的属性和方法。
- 同一个类可以创建多个实例。
三、类的成员
3.1 字段/属性/成员变量
在类中,但是方法外部定义的变量。这样的变量我们称为 “字段” 或 “属性” 或 “成员变量”(三种称呼都可以,一般不会严格区分)。
用于描述一个类包含哪些数据。
class Person {
public String name; // 字段
public int age;
}
class Test {
public static void main(String[] args) {
Person person = new Person();
System.out.println(person.name);
System.out.println(person.age);
}
}
// 执行结果
null
0
注意事项
- 使用 . 访问对象的字段。
- “访问” 既包含读, 也包含写。
- 对于一个对象的字段如果没有显式设置初始值, 那么会被设置一个默认的初值。
3.1.1 成员变量的默认值
3.1.2 认识 null
null 在 Java 中为 “空引用”,表示不引用任何对象。类似于 C 语言中的空指针。如果对 null 进行 . 操作就会引发异常。
代码示例:
class Person {
public String name;
public int age;
}
class Test {
public static void main(String[] args) {
Person person = new Person();
System.out.println(person.name.length()); // 获取字符串长度
}
}
// 执行结果
Exception in thread "main" java.lang.NullPointerException
at Test.main(Test.java:9)
3.1.3 字段就地初始化
很多时候我们不希望字段使用默认值,而是需要我们显式设定初值。
代码示例:
class Person {
public String name = "张三";
public int age = 18;
}
class Test {
public static void main(String[] args) {
Person person = new Person();
System.out.println(person.name);
System.out.println(person.age);
}
}
// 执行结果
张三
18
3.2 method方法
用于描述一个对象的行为。
代码示例:
class Person {
public int age = 18;
public String name = "张三";
public void show() {
System.out.println("我叫" + name + ", 今年" + age + "岁");
}
}
class Test {
public static void main(String[] args) {
Person person = new Person();
person.show();
}
}
// 执行结果
我叫张三, 今年18岁
此处的 show 方法,表示 Person 这个对象具有一个 “展示自我” 的行为。
这样的 show 方法是和 person 实例相关联的。如果创建了其他实例,那么 show 的行为就会发生变化。
Person person2 = new Person();
person2.name = "李四";
person2.age = 20;
person2.show()
// 执行结果
我叫李四, 今年20岁
方法中还有一种特殊的方法称为 构造方法 (construction method)。
在实例化对象的时候会被自动调用到的方法,方法名字和类名相同,用于对象的初始化。
虽然我们前面已经能将属性就地初始化,但是有些时候可能需要进行一些更复杂的初始化逻辑,那么就可以使用构造方法。
3.3 static 关键字
修饰属性: Java静态属性和类相关,和具体的实例无关。换句话说,同一个类的不同实例共用同一个静态属性。
修饰方法: 如果在任何方法上应用 static 关键字,此方法称为静态方法。
- 静态方法属于类,而不属于类的对象。
- 可以直接调用静态方法,而无需创建类的实例。
- 静态方法可以访问静态数据成员,并可以更改静态数据成员的值。
注意事项1:
静态方法和实例无关,而是和类相关。因此这导致了两个情况:
- 静态方法不能直接使用非静态数据成员或调用非静态方法(非静态数据成员和方法都是和实例相关的)。
- this和super两个关键字不能在静态上下文中使用(this 是当前实例的引用,super是当前实例父类实例的引用,也是和当前实例相关)。
注意事项2:
- 我们曾经写的方法为了简单,都统一加上了 static。但实际上一个方法具体要不要带 static,都需要是情形而定。
- main方法为 static 方法。
四、封装
4.1 概述
面向对象编程语言是对客观世界的模拟,客观世界里成员变量都是隐藏在对象内部的,外界无法直接操作和修改。封装可以被认为是一个保护屏障,防止该类的代码和数据被其他类随意访问。要访问该类的数据,必须通过指定的方式。适当的封装可以让代码更容易理解与维护,也加强了代码的安全性。
原则: 将属性隐藏起来,若需要访问某个属性,提供公共方法对其访问。
4.2 封装的步骤
- 使用private关键字来修饰成员变量。
- 对需要访问的成员变量,提供对应的一对getter方法 、setter方法。
4.3 private实现封装
private的含义:
- private是一个权限修饰符,代表最小权限。
- 可以修饰成员变量和成员方法。
- 被private修饰后的成员变量和成员方法,只在本类中才能访问。
private的使用格式:
private 数据类型 变量名;
- 使用private修饰成员变量,代码如下:
public class Student {
private String name;
private int age;
}
- 提供getter方法 / setter方法,可以访问成员变量。
代码示例:
class Person {
private String name; //实例成员变量
private int age;
public void setName(String name) {
//name = name; //不能这样写
this.name = name; //this引用,表示调用该方法的对象
}
public String getName() {
return name;
}
public void show() {
System.out.println("name: "+name+" age: "+age);
}
}
public static void main(String[] args) {
Person person = new Person();
person.setName("caocao");
String name = person.getName();
System.out.println(name);
person.show();
}
// 运行结果
caocao
name: caocao age:0
- getName 即为 getter 方法,表示获取这个成员的值。
- setName 即为 setter 方法,表示设置这个成员的值。
- 当set方法的形参名字和类中的成员属性的名字一样的时候,如果不使用this,相当于自赋值。this 表示当前实例的引用。
- 不是所有的字段都一定要提供 setter / getter 方法,而是要根据实际情况决定提供哪种方法。
那么再聊聊一个问题:类的实现者万一修改了 public 方法 show 的名字,岂不是类的调用者仍然需要大量修改代码吗?
这件事情确实如此,但是一般很少会发生。一般类的设计都要求类提供的 public 方法能比较稳定,不应该频繁发生大的改变。尤其是对于一些基础库中的类,更是如此。每次接口的变动都要仔细考虑兼容性问题。
看完这一大段是不是还有点懵??! 那我们整理一下:为什么要封装?怎么封装?
- 实现封装?用private关键字修饰成员变量。
- private是私有的。被其修饰后,只能在当前类当中使用。
- 每个类都会预留公有的接口。一旦你把这个方法设置为public,那么就不要轻易修改它的属性为其它属性。
- 降低类的调用者对类的使用成本。(会提高开发效率)
- 提供一系列的getter和setter方法。
4.4 this关键字
我们发现setter方法中的形参名字并不符合见名知意的规定,那么如果修改与成员变量名一致,是否就见名知意了呢?
代码示例:
public class Student {
private String name;
private int age;
public void setName(String name) {
name = name;
}
public void setAge(int age) {
age = age;
}
}
经过修改和测试,我们发现新的问题,成员变量赋值失败了。也就是说,在修改了 setter() 的形参变量名后,方法并没有给成员变量赋值! 这是由于形参变量名与成员变量名重名,导致成员变量名被隐藏,方法中的变量名,无 法访问到成员变量,从而赋值失败。 所以,我们只能使用this关键字,来解决这个重名问题。
4.4.1 含义
this代表所在类的当前对象的引用(地址值),即对象自己的引用。
总之记住 :方法被哪个对象调用,方法中的this就代表那个对象。即谁在调用,this就代表谁。
4.4.2 使用格式
this.成员变量名;
使用this修饰方法中的变量,解决成员变量被隐藏的问题,代码如下:
public class Student {
private String name;
private int age;
public void setName(String name) {
//name = name;
this.name = name;
}
public String getName() {
return name;
}
public void setAge(int age) {
//age = age;
this.age = age;
}
public int getAge() {
return age;
}
}
注意事项
4.5 构造方法
当一个对象被创建时候,构造方法用来初始化该对象,给对象的成员变量赋初始值。
注意:无论你是否自定义构造方法,所有的类都有构造方法,因为Java自动提供了一个无参数构造方法, 一旦自己定义了构造方法,Java自动提供的默认无参数构造方法就会失效。
4.5.1 构造方法的定义格式
修饰符 构造方法名(参数列表){
// 方法体
}
构造方法的写法上,方法名与它所在的类名相同。它没有返回值,所以不需要返回值类型,甚至不需要void。
使用构造方法后,代码如下:
public class Student {
private String name;
private int age;
// 无参数构造方法
public Student() {}
// 有参数构造方法
public Student(String name,int age) {
this.name = name;
this.age = age;
}
}
注意事项:
- 如果你不提供构造方法,系统会给出无参数构造方法。
- 如果你提供了构造方法,系统将不再提供无参数构造方法。
- 构造方法是可以重载的,既可以定义参数,也可以不定义参数。
4.6 JavaBean
JavaBean是 Java语言编写类的一种标准规范。符合JavaBean的类,要求类必须是具体的和公共的,并且具有无 参数的构造方法,提供用来操作成员变量的set和get方法。
public class ClassName{
//成员变量
//构造方法
//无参构造方法【必须】
//有参构造方法【建议】
//成员方法
//getter()
//setter()
}
编写符合 JavaBean 规范的类,以学生类为例,标准代码如下:
public class Student {
//成员变量
private String name;
private int age;
//构造方法
public Student() {}
public Student(String name,int age) {
this.name = name;
this.age = age;
}
//成员方法
publicvoid setName(String name) {
this.name = name;
}
public String getName() {
return name;
}
publicvoid setAge(int age) {
this.age = age;
}
publicint getAge() {
return age;
}
}
测试类,代码如下:
public class TestStudent {
public static void main(String[] args) {
//无参构造使用
Student s= new Student();
s.setName("胖胖");
s.setAge(18);
System.out.println(s.getName()+"‐‐‐"+s.getAge());
//带参构造使用
Student s2= new Student("黄黄",18);
System.out.println(s2.getName()+"‐‐‐"+s2.getAge());
}
}
五、代码块
5.1 什么是代码块
使用 {} 定义的一段代码。
根据代码块定义的位置以及关键字,又可分为以下四种:
- 普通代码块
- 构造块
- 静态块
- 同步代码块(后续讲解多线程部分再谈)
5.2 普通代码块
普通代码块:定义在方法中的代码块.
public class Main{
public static void main(String[] args) {
{ //直接使用{}定义,普通方法块
int x = 10 ;
System.out.println("x1 = " +x);
}
int x = 100 ;
System.out.println("x2 = " +x);
}
}
// 执行结果
x1 = 10
x2 = 100
这种用法较少见。
5.3 构造代码块
构造块:定义在类中的代码块(不加修饰符)。也叫:实例代码块。构造代码块一般用于初始化实例成员变量。
class Person{
private String name;//实例成员变量
private int age;
private String sex;
public Person() {
System.out.println("I am Person init()!");
}
//实例代码块
{
this.name = "bit";
this.age = 12;
this.sex = "man";
System.out.println("I am instance init()!");
}
public void show(){
System.out.println("name: "+name+" age: "+age+" sex: "+sex);
}
}
public class Main {
public static void main(String[] args) {
Person p1 = new Person();
p1.show();
}
}
// 运行结果
I am instance init()!
I am Person init()!
name: bit age: 12 sex: man
注意事项: 实例代码块优先于构造函数执行。
5.4 静态代码块
使用static定义的代码块。一般用于初始化静态成员属性。
class Person{
private String name; //实例成员变量
private int age;
private String sex;
private static int count = 0; //静态成员变量 由类共享数据 方法区
public Person() {
System.out.println("I am Person init()!");
}
//实例代码块
{
this.name = "bit";
this.age = 12;
this.sex = "man";
System.out.println("I am instance init()!");
}
//静态代码块
static {
count = 10; //只能访问静态数据成员
System.out.println("I am static init()!");
}
public void show() {
System.out.println("name: "+name+" age: "+age+" sex: "+sex);
}
}
public class Main {
public static void main(String[] args) {
Person p1 = new Person();
Person p2 = new Person(); //静态代码块是否还会被执行?
}
}
注意事项:
- 静态代码块不管生成多少个对象,其只会执行一次,且是最先执行的。
- 静态代码块执行完毕后, 实例代码块(构造块)执行,再然后是构造函数执行。
六、总结
- 一个类可以产生无数的对象,类就是模板,对象就是具体的实例。
- 类中定义的属性,大概分为几类:类属性,对象属性。其中被 static 所修饰的数据属性称为类属性, static修饰的方法称为类方法,特点是不依赖于对象,我们只需要通过类名就可以调用其属性或者方法。
- 静态代码块优先实例代码块执行,实例代码块优先构造函数执行。
- this关键字代表的是当前对象的引用。并不是当前对象。