初识面向对象
来源:互联网 发布:软件著作权 开源代码 编辑:程序博客网 时间:2024/05/21 07:35
面向对象概念
理解面向对象
- 面向对象是相对面向过程而言
- 面向对象和面向过程都是一种思想
- 面向过程强调的是功能行为
- 面向对象将功能封装进对象,强调具备了功能的对象
- 面向对象是基于面向过程的
面向对象的特点
- 是一种符合人们思考习惯的思想
- 可以将复杂的事情简单化
- 将程序员从执行者转换成了指挥者(即从过程的执行者,转换成了对象的指挥者)
- 完成需求时:
- 先要去找具有所需的功能的对象来用
- 如果该对象不存在,那么创建一个具有所需功能的对象
- 这样简化开发并提高复用
面向对象开发,设计,特征
- 开发的过程:其实就是不断的创建对象,使用对象,指挥对象做事情
- 设计的过程:其实就是在管理和维护对象之间的关系
- 面向对象有3个特征:封装(encapsulation)、继承(inheritance)、多态(polymorphism)
类与对象的关系
类就是对现实生活中事物的描述;对象就是这类事物实实在在存在的个体。
比如:现实生活中的对象:张三,李四。若想要描述:即提取对象中共性内容,也即对具体对象的抽象。描述时,这些对象的共性有:姓名,年龄,性别,学习java的功能。映射到java中,描述就是class定义的类,具体对象就是对应java在堆内存中用new建立的实体。
类与对象的关系如图所示:
可以这样理解类与对象的关系:
- 类就是图纸
- 汽车就是堆内存中的对象
例,需求1:描述汽车(颜色、轮胎数)。
(其实定义类)描述事物,其实就是在描述事物的属性和行为。
- 属性对应类中变量,行为对应类中的函数(方法)
- 属性和行为共同成为类中的成员(成员变量和成员函数)
class Car { // 描述颜色 String color = "红色"; // 描述轮胎数 int num = 4; // 运行行为 void run() { System.out.println(color+"..."+num); }}
描述完汽车,接下来就是生产汽车,在java中通过new操作符来完成,其实就是在堆内存产生一个实体。即:
Car c = new Car(); // c就是一个类类型变量。记住:类类型变量指向对象。
需求2:将已有车的颜色改成蓝色,就需要指挥该对象做事情,在java中指挥方式是:对象.对象成员
。
c.color = "blue";
对象内存结构图
试分析如下代码:
Car c = new Car();c.color = "blue";c.run();Car c1 = new Car();c1.run();
在内存中的表示:
而对于代码:
Car c = new Car();c.num = 5;Car c1 = c;c1.color = "green";c.run();
在内存中表示为:
可以得出成员变量和局部变量的区别:
- 源代码中定义的位置不同。
成员变量定义在类中。
局部变量定义在方法中(只要是类的下一级大括号都是局部的),也可以定义在语句中。 - 内存中的存储位置不同。
成员变量存储在堆内存的对象中。
局部变量存储在栈内存的方法中。 - 生命周期不同。
成员变量随着对象的出现而出现。
局部变量随着所属区间的运行而出现,随着所属区间的结束而释放。
匿名对象
匿名对象是对象的简化形式。
匿名对象使用方式:
- 当对对象的方法只调用一次时,可以用匿名对象来完成,这样写比较简化。如果对一个对象进行多个成员调用,必须给这个对象起个名字
- 可以将匿名对象作为实际参数进行传递
例,
new Car().num = 5;new Car().color = "blue";new Car().run();
在内存中的表现形式为:
需求3:汽车修配厂对汽车进行改装,将来的车都改成黑色,3个轮胎。
public static void show(Car c) { c.num = 3; c.color = "black"; c.run();}
将匿名对象作为实际参数进行传递,如下:
public static void main(String[] args) { show(new Car());}
此时,在内存中的表现形式为:
而代码
public static void main(String[] args) { Car q = new Car(); show(q);}
在内存中的表示如图:
若要让堆内存中的对象成为垃圾,可让q = null
。
封装(Encapsulation)
封装:是指隐藏对象的属性和实现细节,仅对外提供公共访问方式(接口)。
好处:
- 将变化隔离
- 便于使用
- 提高重用性
- 提高安全性,不允许直接访问细节,并通过公共的方式来访问,可实现可控
封装原则:
- 将不需要对外提供的内容都隐藏起来
- 把属性都隐藏,提供公共方法对其访问
private(私有)关键字
- private:私有,权限修饰符,用于修饰类中的成员(成员变量、成员函数)。私有只在本类中有效。
- 将成员变量私有化,对外提供对应的
set
,get
方法对其进行访问。提高对数据访问的安全性。
具体到实例,即是:将age
私有化以后,类以外即使建立对象也不能直接访问了,但是人应该有年龄,就需要在Person
类中提供对应的访问age
的方式。之所以对外提供访问方式,就因为可以在访问方式中加入逻辑判断等语句,对访问的数据进行操作,提高代码的健壮性。代码如下:
class Person{ private /*私有,权限修饰符,访问权限就降低了*/ int age; /* 对私有的数据,可以通过方法的方式对其进行访问。 */ public void setAge(int a) { // 可以对数据进行控制 if (a < 0 || a > 130) { // System.out.println(a + ",数值是错误的"); // 抛出异常。 throw new RuntimeException(a + ",数值是错误的"); } else { age = a; } } public int getAge() { return age; } void speak() { System.out.println("age = " + age); }}class PersonDemo { public static void main(String[] args) { Person p = new Person(); // p.age = -20; p.setAge(-40); // p.speak(); }}
注意:私有仅仅是封装的一种表现形式。也即封装的体现之一:将属性私有化,对外提供对应的setXxx、getXxx方法来访问。
构造函数
对象一建立就会调用与之对应的构造函数。
特点:
- 函数名和类名相同
- 没有返回值类型
- 没有具体的返回值
作用:可用于给对象进行初始化。
构造函数和一般函数的区别:构造函数和一般函数在写法上有不同,在运行上也有不同。构造函数在对象创建时执行,给对象初始化,而且只执行一次。而一般函数是对象调用时才执行,是给对象添加对象具备的功能。一个对象建立,构造函数只运行一次,而一般函数可以被该对象调用多次。
当初new对象时,也没有构造函数啊?那这个对象是怎么初始化的呢?
- 注意1:定义的每一个类中,都有一个默认的空参数构造函数。
- 注意2:一旦在类中自定义了构造函数后,默认的构造函数就没有了。
如:
class Car { // Car() {} // 类中默认的空参构造函数,专门用于创建对象初始化用的}class CarDemo { public static void main(String[] args) { Car c = new Car(); }}
构造函数的细节:
细节一:构造函数中有return语句吗?可以有,用于结束初始化的。如:
Person(String n){ name = n; return;}
细节二:一般函数的名字是可以和类名一样的,但是不符合书写规范。如以下代码是可以通过编译的。
class Person{ void Person() // 可以编译通过,一般函数的名字是可以和类名一样的,但是不符合书写规范 { } void showPerson() {}}
细节三:构造函数里面是可以调用一般函数。
细节四:构造函数是可以私有化的,只在本类中使用,而且构造函数一旦私有化,其他程序就无法创建该类的对象。原因:无法对创建的对象进行初始化。
总结:
- 当一个类中没有定义构造函数时,那么系统会默认给该类加入一个空参数的构造函数。当在类中自定义了构造函数后,默认的构造函数就没有了。
- 一个类中默认会有一个空参数的构造函数,这个默认的构造函数的权限和所属类一致。如果类被public修饰,那么默认的构造函数也带public修饰符;如果类没有被public修饰,那么默认的构造函数也没有public修饰。简而言之:默认构造函数的权限是随着类的变化而变化的。
- 什么时候定义构造函数呢?
答:当分析事物时,该事物存在具备一些特性或者行为,那么将这些内容定义在构造函数中。
废话少说,直接上代码,分析一下构造函数的内存图。例有如下代码:
class Person{ private String name; private int age; Person(String n) { name = n; } Person(String n, int a) { name = n; age = a; } public void setName(String n) { name = n; } public String getName() { return name; } public void setAge(int a) { age = a; } public int getAge() { return age; } public void show() { System.out.println("name = " + name + ",age = " + age); }}class PersonDemo{ public static void main(String[] args) { Person p1 = new Person("xiaoqiang", 30); p1.show(); }}
则构造函数的内存图如下图所示:
this关键字
下面我们通过构造函数之间的调用来引出this关键字的讲解。试着思考一下:若构造函数私有,则就表示只在本类中有效,那么该如何访问呢?这里有个注意点,即构造函数只能被构造函数调用,不能直接被一般方法调用。还是回到我们的问题中来,构造函数之间该如何访问呢?答案是通过关键字this来解决。
this看上去,是用于区分局部变量和成员变量同名情况(当成员变量和局部变量同名时,可以通过this关键字区分。)。那么this到底代表的是什么呢?答案是:this代表本类的对象,到底代表哪一个呢?this代表它所在函数所属对象的引用,简单说:哪个对象在调用this所在的函数,this就代表哪个对象。
其实在Java里面有一个机制:只要用对象调用了方法,这个方法里面就持有一个引用,该引用指向哪个对象呢?哪个对象调用我,我就指向谁。总结一点就是:只要是直接被对象调用的方法都持有this引用。(凡是访问了对象中的数据的方法都持有this引用)
废话不多说,也是直接上代码,看看构造函数之间的调用以及其用到的this关键字。例有如下代码:
class Person{ private String name; private int age; private Person(String n) { name = n; } Person(String n, int a) { this(n); age = a; } public void show() { System.out.println("name = " + name + ",age = " + age); }}class ThisDemo{ public static void main(String[] args) { Person p = new Person("小明", 21); p.show(); }}
以上构造函数之间的调用用图来表示即为:
this带上参数列表的方式就可以访问本类中的其他构造函数。比如:this("lisi"):
访问的就是本类中带一个字符串参数的构造函数。还有一点要注意,即用于调用构造函数的this语句必须定义在构造函数的第一行,因为初始化动作要先执行。
this的应用:当定义类中功能时,该函数内部要用到调用该函数的对象时,这时用this来表示这个对象。但凡本类功能内部使用到了本类对象都用this表示。用例子来说话:
class Person { private String name; private int age; Person(int age) { this.age = age; } Person(String name) { this.name = name; } Person(String name, int age) { this.name = name; this.age = age; } public void speak() { System.out.println("name="+this.name+"...age="+this.age); this.show(); } public void show() { System.out.println(this.name); } /* 需求:给人用于比较年龄是否相同的功能,也即是否是同龄人。 */ public boolean compare(Person per) { return this.age == per.age; }}class PersonDemo3 { public static void main(String[] args) { Person p = new Person(20); Person p1 = new Person(25); boolean b = p1.compare(p2); System.out.println(b); }}
static(静态)关键字
static用法:是一个修饰符,用于修饰成员(成员变量、成员函数)。
当成员被静态修饰后,就多了一个调用方式,除了可以被对象调用外,还可以直接被类名调用:类名.静态成员
。
被修饰后的成员具备以下特点:
- 随着类的加载而加载,类的消失而消失,说明它的生命周期最长。
- 优先于对象存在,明确一点:静态是先存在的,对象是后存在的。
- 被所有对象所共享。
- 可以直接被类名所调用。
静态使用注意事项:
- 静态方法只能访问静态成员,不能访问非静态成员,这就是静态方法的访问局限性。而非静态方法既可以访问静态也可以访问非静态。
- 静态方法中不可以定义
this
、super
关键字。因为静态优先于对象存在,所以静态方法中不可以出现this
。 - 主函数是静态的。
那么static关键字在程序开发中,什么时候使用呢?
- 成员变量:如果数据在所有对象中的都是一样的,直接静态修饰。
- 成员函数:如果函数没有访问过对象中的属性数据,那么该函数就是静态的。
下面我们着重看一下成员变量和静态变量的区别:
- 名称上的区别
成员变量也叫实例变量。
静态变量也叫类变量。 - 内存存储上的区别
成员变量存储在堆内存的对象中。
静态变量存储在方法区的静态区中。 - 生命周期不同
成员变量随着对象的出现而出现,随着对象的消失而消失。
静态变量随着类的出现而出现,随着类的消失而消失。
下面我们通过实际代码来看一下静态特点。例有如下代码:
class Person{ private String name; private int age; // public static String country = "CN"; // 全局变量 static String country = "CN"; Person(String name, int age) { this.name = name; this.age = age; } public void show() { System.out.println("name = " + name + ",age = " + age); } public static void sleep() { System.out.println("呼呼"); // System.out.println("呼呼..." + name); // 无法从静态上下文中引用非静态变量name }}class StaticDemo{ public static void main(String[] args) { Person p = new Person("lisi", 21); p.show(); /* 如果创建对象调用sleep方法,发现,并没有使用对象中的数据。 该对象的建立是没有意义的。 该方法所属于Person.class,可以通过类名的方式来访问。 注意:用类名直接调用的方法必须通过指定修饰符来修饰,就是关键字static */ Person.sleep(); }}
以上代码一图以蔽之:
静态代码块
格式:
static { 静态代码块中的执行语句}
特点:随着类的加载而执行,只执行一次,并优先于主函数。用于给类进行初始化。
其应用场景为:类不需要创建对象,但是需要初始化,这时将部分代码存储到静态代码块中。
例,
class StaticCode { static { System.out.println("a"); }}class StaticCodeDemo { static { System.out.println("b"); } public static void main(String[] args) { new StaticCode(); // 将StaticCode.class这个类加载进内存 new StaticCode(); // 注意StaticCode.class已经加载进内存,不会再次加载 System.out.println("over"); } static { System.out.println("c"); }}
输出结果:
b
c
a
over
注意:StaticCode s = null;
,StaticCode类并没有被加载进内存。只有用到了类中的内容,才涉及类的加载问题,光建立引用,是不会加载的。
构造代码块
格式:
{ 构造代码块中的执行语句}
构造代码块定义的是不同对象共性的初始化内容。
作用:给对象进行初始化,对象一建立就运行,而且优先于构造函数执行。
和构造函数的区别:构造代码块是给所有对象进行统一初始化,而构造函数是给对应的对象初始化。
例,
class Person { private String name; private int age; // 构造代码块 { cry(); } Person() { System.out.println("A:name="+name+",age="+age); } Person(String n) { name = n; System.out.println("B:name="+name+",age="+age); } Person(String n, int a) { name = n; age = a; System.out.println("C:name="+name+",age="+age); } public void cry() { System.out.println("cry......."); }}class PersonDemo { public static void main(String[] args) { Person p1 = new Person(); Person p2 = new Person("lisi"); }}
学了静态代码块和构造代码块之后,极有可能遇到这样的面试题:
class StaticCode { int num = 9; StaticCode() { System.out.println("b"); } static { System.out.println("a"); } { System.out.println("c"+this.num); } StaticCode(int x) { System.out.println("d"); } public static void show() { System.out.println("show run"); }}class StaticCodeDemo { public static void main(String[] args) { new StaticCode(4); }}
问运行结果?
答:输出为:
a
c9
d
主函数
主函数:是一个特殊的函数,作为程序的入口,可以被JVM调用。
主函数的定义:
public
:代表着该函数访问权限是最大的。static
:代表主函数随着类的加载就已经存在了。void
:主函数没有具体的返回值。main
:不是关键字,但是是一个特殊的单词,可以被JVM设别。String[] args
:函数的参数,参数类型是一个数组,该数组中的元素是字符串,也称为字符串类型的数组。
主函数是固定格式的:JVM设别。JVM在调用主函数时,传入的是new String[0];
。我们可以通过以下代码测试:
class MainDemo { public static void main(String[] args) { System.out.println(args); // [Ljava.lang.String;@139a55 System.out.println(args.length); // 0 }}
须知主函数也是一个函数,即支持函数重载,所以以下代码也是可行的:
class MainDemo { // 函数的重载 public static void main(int x) { } public static void main(String[] args, int x) { } public static void main(String[] args) { }}
我们也可以在运行的时候指定输入一些字符串,打印在控制台上。
class MainDemo { public static void main(String[] args) { for (int x = 0; x < args.length; x++) { System.out.println(args[x]); } }}
运行时指令:java MainDemo li yun ling
。
输出:
li
yun
ling
当然了,如果不爽也可以这样做:
class MainDemo { public static void main(String[] args) { String[] arr = {"haha", "hehe", "heihei", "xixi", "haihai"}; MainTest.main(arr); }}class MainTest { public static void main(String[] args) { for (int x = 0; x < args.length; x++) { System.out.println(args[x]); } }}
静态的应用
什么时候使用静态?
要从两方面下手:因为静态修饰的内容有成员变量和函数。
什么时候定义静态变量(类变量)呢?
当对象中出现共享数据时,该数据被静态所修饰,对象中的特有数据要定义成非静态,存在堆内存中。
什么时候定义静态函数呢?
当功能内部没有访问到非静态数据(对象的特有数据),那么该功能就定义成静态的。
下面以一个例子来说明静态的应用。
每一个应用程序中都有共性的功能,可以将这些功能进行抽取,独立封装,以便复用。我们试图建立一个可以对数组进行操作的工具类,该类中提供了获取最值、排序等功能。
分析:虽然可以通过建立ArrayTool
的对象使用这些工具方法,对数组进行操作,发现了问题:
- 对象是用于封装数据的,可是
ArrayTool
对象并未封装特有数据 - 操作数组的每一个方法都没有用到
ArrayTool
对象中的特有数据
这时就考虑,让程序更严谨,是不需要对象的。可以将ArrayTool
中的方法都定义成static
的。直接通过类名调用即可。
将方法都静态后,可以方便于使用,但是该类还是可以被其他程序建立对象的。为了更为严谨,强制让该类不能建立对象。可以通过将构造函数私有化完成。并且,为了能生成API文档,我们加入java文档注释。代码为:
/**这是一个可以对数组进行操作的工具类,该类中提供了获取最值、排序等功能。@author 李阿昀@version V1.1*/public class ArrayTool { // ArrayTool() {} /** 空参数构造函数 */ private ArrayTool() { } /** 获取一个整型数组中的最大值 @param arr 接受一个int类型的数组 @return 会返回一个该数组中的最大值 */ public static int getMax(int[] arr) { int max = 0; for (int x = 0; x < arr.length; x++) { if(arr[x] > arr[max]) max = x; } return arr[max]; } /** 获取一个整型数组中的最小值 @param arr 接受一个int类型的数组 @return 会返回一个该数组中的最小值 */ public static int getMin(int[] arr) { int min = 0; for (int x = 0; x < arr.length; x++) { if(arr[x] < arr[min]) min = x; } return arr[min]; } /** 给int数组进行选择排序 @param arr 接受一个int类型的数组 */ public static void selectSort(int[] arr) { for (int x = 0; x < arr.length - 1; x++) { for (int y = x + 1; y < arr.length; y++) { if(arr[x] > arr[y]) { swap(arr, x, y); } } } } /** 给int数组进行冒泡排序 @param arr 接受一个int类型的数组 */ public static void bubbleSort(int[] arr) { for (int x = 0; x < arr.length - 1; x++) { for (int y = 0; y < arr.length - x - 1; y++) { if(arr[y] > arr[y+1]) { swap(arr, y, y+1); } } } } /** 给数组中的元素进行位置的置换 @param arr 接受一个int类型的数组 @param a 要置换的位置 @param b 要置换的位置 */ private static void swap(int[] arr, int a, int b) { int temp = arr[a]; arr[a] = arr[b]; arr[b] = temp; } /** 用于打印数组中的元素。打印形式是:[element1, element2, ...] @param arr 接受一个int类型的数组 */ public static void printArray(int[] arr) { System.out.print("["); for (int x = 0; x < arr.length; x++) { if(x != arr.length - 1) System.out.print(arr[x]+", "); else System.out.println(arr[x]+"]"); } }}
接下来,将ArrayTool.class
文件发送给其他人,其他人只要将该文件设置到classpath
路径下,就可以使用该工具类。但是,很遗憾,该类中定义了多少个方法,对方不清楚,因为该类并没有使用说明书。开始制作程序的说明书,java的说明书通过文档注释来完成。
即javac -d myhelp -author -version ArrayTool.java
。 myhelp
:为文档生成的目录,默认为当前目录,也可以指定为其他目录 -author
:文档作者的名字 -version
:文档版本
对象的初始化流程
到了最后一个知识点了,即对象的初始化流程。我们还是一个例子来说明,例有如下代码:
class Person{ private int age = 8; // 显示初始化 { // 构造代码块。给所有对象进行初始化的。构造函数只给对应的对象初始化。 System.out.println("constructor code run!!!......." + age); } Person() { // 隐藏了以下三句代码: // 1. super()调用父类构造函数 // 2. 显示初始化 // 3. 构造代码块初始化。 System.out.println("person run!!!"); } Person(int age) { this.age = age; System.out.println("person(age) run!!!"); }}/*创建一个对象的流程:1,加载指定的字节码文件进内存2,通过new在堆内存中开辟空间,并分配首地址值3,对对象中的属性进行默认初始化4,调用与之对应的构造函数,构造函数压栈5,构造函数中执行隐式的语句super()访问父类中的构造函数6,对属性进行显示初始化7,调用类中的构造代码块8,执行构造函数中自定义的初始化代码9,初始化完毕,将地址赋值给指定的引用*/class ConsCodeDemo { public static void main(String[] args) { Person p = new Person(); }}
试着说明Person p = new Person();
该句话都做了什么事情呢?
答:创建一个对象的流程为:
- 加载指定的字节码文件进内存
- 通过new在堆内存中开辟空间,并分配首地址值
- 对对象中的属性进行默认初始化
- 调用与之对应的构造函数,构造函数压栈
- 构造函数中执行隐式的语句super()访问父类中的构造函数
- 对属性进行显示初始化
- 调用类中的构造代码块
- 执行构造函数中自定义的初始化代码
- 初始化完毕,将地址赋值给指定的引用
- 初识面向对象
- 初识面向对象
- 初识Java面向对象
- 初识面向对象
- 初识面向对象
- OC--面向对象初识
- Java初识面向对象
- 初识面向对象
- 面向对象初识
- 初识面向对象
- 三十三、面向对象初识
- 初识面向对象设计模式
- 初识面向对象的编程
- 初识Javascript的面向对象
- OOP面向对象技术初识
- 理解面向对象编程(初识)
- 05-java面向对象初识
- 【java】初识面向对象程序设计
- 简单化搭建 Docker 数据中心
- python+selenium(环境的安装)
- 读者写者算法
- 16哈理工新生赛 E Nine Digits (BFS+康拓展开)
- 2048(游戏)
- 初识面向对象
- Linux编译内核(4.2.6)并添加系统调用
- 十一个顶级的Git 客户端,绝对很实用!
- log4j日志配置文件log4j.properties
- Freeline - Android平台上的秒级编译方案
- Python随机生成均匀分布在三角形内(或者任意多边形内)的点
- 什么是左连接,右连接,内连接和全连接
- C语言的变量作用域
- 排序算法—快速排序