文章目录
- 认识面向对象
- 面向过程和面向对象的区别
- 面向对象具有三大特征:
- 类
- 类和对象的概念
- 类的定义
- 对象的创建和使用
- 对象的创建
- 对象的使用
- 成员变量和局部变量的区别
- 匿名对象的概述和应用
- 封装的概述
- private关键字的概述和特点
- this关键字
- static关键字
- 静态属性、静态方法
- 代码块的概述和分类
- 静态代码块
认识面向对象
面向过程和面向对象的区别
面向过程和面向对象有什么关系呢?面向过程其实是最为实际的一种思考方式,就算是面向对象的方法也是含有面向过程的思想。可以说面向过程是一种基础的方法。它考虑的是实际地实现。一般的面向过程是从上往下步步求精。 面向对象主要是把事物给对象化,对象包括属性与行为。当程序规模不是很大时,面向过程的方法还会体现出一种优势。因为程序的流程很清楚,按着模块与函数的方法可以很好的组织。但对于复杂而庞大的系统来说,面向过程显得就很无力了。
使用面向对象编程思想开发系统,在现代开发中会将面向对象贯穿
整个过程,一般包括:
OOA/OOD/OOP:
① OOA:面向对象分析(Object-Oriented Analysis)
② OOD:面向对象设计(Object-Oriented Design)
③ OOP:面向对象编程(Object-Oriented Programming)
面向对象具有三大特征:
① 封装(Encapsulation)
② 继承(Inheritance)
③ 多态(Polymorphism)
那么什么是面向对象思想呢?
就是把这些步骤和功能在进行封装,封装时根据不同的功能,进行不同的封装,功能类似的封装在一起。
这样结构就清晰了很多。用的时候,找到对应的类就可以了。这就是面向对象的思想。
面向对象思想特点
a:是一种更符合我们思想习惯的思想 懒人思想
b:可以将复杂的事情简单化
c:将我们从执行者变成了指挥者
面向对象开发就是不断的创建对象,使用对象,指挥对象做事情。
类
类和对象的概念
生活实例
面向过程:洗衣服:换下脏衣服—盛水----浸泡------手搓----漂清—晾干
面向对象:全自动洗衣机----------- 一键洗衣
我们学习编程是为了什么?
我们学习编程语言,就是为了模拟现实世界的事物,实现信息化。比如:去超市买东西的计费系统,去银行办业务的系统。
那么我们如何描述现实世界事物
举例: 描述学生事物
姓名 , 年龄 , 性别 ....
学习 , 吃饭 , 睡觉 ....
属性: 就是该事物的描述信息
行为: 就是该事物能够做什么
我们学习编程语言,就是为了模拟现实中的事物,我们学习的Java语言最基本单位是类,所以,我们就应该把事物用一个类来体现。
由此我们就得到了现实中的事物和类的对应关系
事物 类
属性 ----------------- 成员变量
行为 ----------------- 成员方法
定义类其实就是定义类的成员(成员变量和成员方法)
- 成员变量 和以前定义变量是一样的,只不过位置发生了改变。在类中,方法外。
- 成员方法 和以前定义方法是一样的,只不过把static去掉,后面在详细讲解static的作用。
类和对象的概念
a:类:是一组具有共同特征的集合,是一堆实例抽象而来。
b:对象:是该类的实例化
c:举例:
类 学生
对象 一个学生就是一个对象
类的定义
[修饰符] class 类名 {
类体 = 属性 + 方法
}
以上为类的简单定义,实际上一个完整的类的定义要比以上语法复杂一些,以后再慢慢补充
学生类
public class Student { //定义一个类:class
//成员属性,成员变量:定义在类中方法外
String name;
int age;
char sex;
//成员功能,成员方法
public void eat() {
System.out.println("吃饭");
}
public void sleep() {
System.out.println("睡觉");
}
public void playGame() {
System.out.println("打豆豆");
}
}
对象的创建和使用
对象的创建
public class StudentTest {
public static void main(String[] args) {
//创建一个学生对象
Student s1 = new Student();
//再创建一个学生对象
Student s2 = new Student();
//以上代码其实和这行代码差不多
int i = 10;
}
}
对象的使用
public static void main(String[] args) {
//如果使用定义好的一个类
// 类:他是一个抽象的概念,他不能直接使用,如果要使用,我们需要对类进行实例化
//所谓实例化,就是创建该类对象,因为对象才是类的具体表现
// 怎么创建一个类的对象呢,使用关键字new
Student s1 = new Student();
//该类对象创建成功后,使用该类对象,就可以调用类中的属性和功能
System.out.println(s1.name;);
System.out.println(s1.age);
System.out.println(s1.sex);
//然后给属性赋值
s1.name = "王五";
s1.age = 23;
s1.sex = '男';
//获取属性的值
System.out.println(s1.name;);
System.out.println(s1.age);
System.out.println(s1.sex);
//使用功能
s1.eat();
s1.sleep();
s1.playGame();
}
通过学生类实例化的学生对象对象的年龄,不赋值的情况下获取了到的年龄都是 0,这是因为在 java 语言当中,当实例变量没有手动赋值,在创建对象的时候,也就是说在 new 的时候,系统会对实例变量默认赋值,它们的默认值请参考下表:
成员变量和局部变量的区别
- 在类中的位置不同
成员变量:在类中方法外
局部变量:在方法定义中或者方法声明上 - 在内存中的位置不同
成员变量:在堆内存
局部变量:在栈内存 - 生命周期不同
成员变量:随着对象的创建而存在,随着对象的消失而消失
局部变量:随着方法的调用而存在,随着方法的调用完毕而消失 - 初始化值不同
成员变量:有默认初始化值
局部变量:没有默认初始化值,必须定义,赋值,然后才能使用。
注意事项: 局部变量名称可以和成员变量名称一样,在方法中使用的时候,采用的是就近原则。
方法的形式参数是类名的时候如何调用
- Java中参数传递问题
形式参数
基本类型:形式参数的改变不影响实际参数
引用类型:形式参数的改变直接影响实际参数 - 方法的参数是类名
如果你看到了一个方法的形式参数是一个类类型(引用类型),这里其实需要的是该类的对象。
匿名对象的概述和应用
- 什么是匿名对象
就是没有名字的对象 - 匿名对象应用场景
(1). 调用方法,仅仅只调用一次的时候。
(2). 匿名对象可以作为实际参数传递
封装的概述
- 封装的引入
通过学生案例,给年龄赋值为负数引出数据问题。
然后通过private解决这个问题。最后说其实这就是封装。 - 封装概述
是指隐藏对象的属性和实现细节,仅对外提供公共访问方式。 - 封装好处
隐藏实现细节,提供公共的访问方式
提高了代码的复用性
提高安全性。 - 封装原则
将不需要对外提供的内容都隐藏起来。
把属性隐藏,提供公共方法对其访问。
private关键字的概述和特点
- private关键字特点
a:是一个权限修饰符
b:可以修饰成员变量和成员方法
c:被其修饰的成员只能在本类中被访问 - private最常见的应用:
a:把成员变量用private修饰
b:提供对应的getXxx()和setXxx()方法
案例
public class Phone {
//私有成员变量
//this 表示本类的一个引用。你可以理解为本类的一个对象,哪个对象调用这个方法,那么方法中的this就代表这个对象
private String name;
private double price;
//提供公共的set get 方法
public void setName(String name){
//方法中的this 就代表那个调用者,谁调用就代表谁
// p.name=name;
//就近原则
System.out.println("this代表调用者的地址值"+this);
this.name=name;
}
public void setPrice(double price){
// p.price=price;
System.out.println("this代表调用者的地址值" + this);
this.price=price;
}
public String getName(){
return name;
}
public double getPrice(){
return price;
}
public static void main(String[] args) {
Phone phone = new Phone();
System.out.println(phone+"调用者的地址值");
phone.setName("小米");
phone.setPrice(500);
String name = phone.getName();
double price = phone.getPrice();
System.out.println(name+"===="+price);
System.out.println("------------------------");
Phone phone2 = new Phone();
System.out.println(phone2 + "调用者的地址值");
phone2.setName("小米");
phone2.setPrice(500);
String name2 = phone2.getName();
double price2 = phone2.getPrice();
System.out.println(name2 + "====" + price2);
}
在上文中我们看到这样的代码
this.name=name;
这个this.是什么意思呢?又有什么作用呢?
this关键字
- 为什么要有this
当我们的局部变量和成员变量相同的时候,如果我们不使用this关键字,那么会导致一个问题:就是局部变量隐藏了成员变量的问题 - this关键字特点
this 可以看做一个变量,它是一个引用,存储在 Java 虚拟机堆内存的对象内部, this 这个引用保存了当前对象的内存地址指向自身,任何一个堆内存的 java 对象都有一个 this,也就是说创建 100 个 java 对象则分别对应 100 个 this。 - this的应用场景
this 指向“当前对象”,也可以说 this 代表“当前对象”, this 可以使用在实例方法中以及构造方法中,语法格式分别为“this.”和“this(…)”。this 不能出现在带有 static 的方法当中。 - this 使用在构造方法中
this 还有另外一种用法,使用在构造方法第一行(只能出现在第一行,这是规定,记住就行),通过当前构造方法调用本类当中其它的构造方法,其目的是为了代码复用。调用时的语法格式是: this(实际参数列表)
static关键字
静态属性、静态方法
- 当一个类的所有对象的某个“属性值”不会随着对象的改变而变化的时候,建议将该属性定义为静态属性(或者说把这个变量定义为静态变量),静态变量在类加载的时候初始化,存储在方法区当中,不需要创建对象,直接通过“类名”来访问。
- 如果静态变量使用“引用”来访问,可以吗,如果可以的话,这个访问和具体的对象有关系吗?看以下代码:
public class ManTest {
public static void main(String[] args) {
//静态变量比较正式的访问方式
System.out.println("性别 = " + Man.sex);
//创建对象
Man jack = new Man(100);
//使用“引用”来访问静态变量可以吗?
System.out.println("性别 = " + jack.sex);
//对象被垃圾回收器回收了
jack = null;
//使用“引用”还可以访问吗?
System.out.println("性别 = " + jack.sex);
}
}
运行结果如下图所示:
通过以上代码以及运行结果可以看出,静态变量也可以使用“引用”去访问,但实际上在执行过程中,“引用”所指向的对象并没有参与,如果是空引用访问实例变量,程序一定会发生空指针异常,但是以上的程序编译通过了,并且运行的时候也没有出现任何异常,这说明虽然表面看起来是采用“引用”去访问,但实际上在运行的时候还是直接通过“类”去访问的。静态方法也是这样。
代码块的概述和分类
- 代码块概述
在Java中,使用{}括起来的代码被称为代码块。
- 代码块分类
根据其位置和声明的不同,可以分为局部代码块,构造代码块,静态代码块,同步代码块(多线程讲解)。
- 常见代码块的应用
a:局部代码块
在方法中出现;限定变量生命周期,及早释放,提高内存利用率b:构造代码块
在类中方法外出现;多个构造方法方法中相同的代码存放到一起,每次调用构造都执行,并且在构造方法前执行c:静态代码块
在类中方法外出现,加了static修饰
在类中方法外出现,并加上static修饰;用于给类进行初始化,在加载的时候就执行,并且只执行一次。
大家看看这段代码
class Student {
static {
System.out.println("Student 静态代码块");
}
{
System.out.println("Student 构造代码块");
}
public Student() {
System.out.println("Student 构造方法");
}
}
class StudentDemo {
static {
System.out.println("StudentDemo的静态代码块");
}
public static void main(String[] args) {
System.out.println("我是main方法");
Student s1 = new Student();
Student s2 = new Student();
}
}
不知道其他人怎么样,反正我看到这些代码的时候我是懵逼的。。。(笑哭脸)
那大家猜猜结果呀。
StudentDemo的静态代码块
我是main方法
Student 静态代码块
Student 构造代码块
Student 构造方法
Student 构造代码块
Student 构造方法
这些都是各种代码块的特点造成的结果。
静态代码块
- 静态代码块的语法格式是这样的:
类{
//静态代码块
static{
java 语句;
}
}
静态代码块在类加载时执行,并且只执行一次。只在类加载时刻执行一次,如果需要在类加载是实现某些功能,那么静态代码块就排上用场了。
2. 一个类当中可以编写多个静态代码块(尽管大部分情况下只编写一个),并且静态代码块遵循自上而下的顺序依次执行,所以有的时候放在类体当中的代码是有执行顺序的(大部分情况下类体当中的代码没有顺序要求,方法体当中的代码是有顺序要求的,方法体当中的代码必须遵守自上而下的顺序依次逐行执行),另外静态代码块当中的代码在 main 方法执行之前执行,这是因为静态代码块在类加载时执行,并且只执行一次。
public class StaticTest01 {
//静态代码块
static{
System.out.println(2);
}
//静态代码块
static{
System.out.println(1);
}
//main 方法
public static void main(String[] args) {
System.out.println("main execute!");
}
//静态代码块
static{
System.out.println(0);
}
}
运行结果:
3. 无法从静态代码中直接使用实例变量,因为实例变量必须要先创建对象才能使用,当然也可以在一些变量之前加上‘static’,使之成为静态变量,从而进行访问。
public class StaticTest02 {
int i = 100;
static{
System.out.println(i);
}
}
结果如下:
4. 静态方法
静态方法,比较方便调用,不需要创建对象,直接使用类名
就可以访问。