------Java培训、Android培训、iOS培训、.Net培训、期待与您交流! -------
1. 面向对象概念
1.1 概念
面向对象是相对面向过程而言,面向对象和面向过程都是一种思想。
面向过程:强调的是功能行为。代表语言:C语言。
例子:把大象装进冰箱
1. 打开冰箱。
2. 存储大象。
3. 关上冰箱。
"打开"、"存储"、"关上"都是功能行为,在代码中的直观体现就是函数或者方法,这就是一种面向过程的以功能行为为主体的思想体现。
面向对象:将功能封装进对象,强调具备了功能的对象。代表语言:Java、C++、C#。
例子:把大象装进冰箱
1. 冰箱打开。
2. 冰箱存储。
3. 冰箱关闭。
可以看到,所有的操作都是以"冰箱"为主体,而不是功能行为。也就是说冰箱自己已经具备"打开"、"存储"、"关上"的行为功能,我们只需要让 冰箱执行它具备的功能就可以了。这就是一种面向对象的以执行功能的对象为主体的思想体现。
1.2 特点
面向对象是一种符合人们思考习惯的思想,可以将复杂的事情简单化,将程序员从执行者转换成了指挥者。
完成需求时:
1. 先要去找具有所需功能的对象来用。
2. 如果该对象不存在,那么创建一个具有所需功能的对象。
这样可以简化开发并提高复用。
完成需求时:
1. 先要去找具有所需功能的对象来用。
2. 如果该对象不存在,那么创建一个具有所需功能的对象。
这样可以简化开发并提高复用。
1.3 开发设计中的特征
开发的过程:
其实就是不断的创建对象,使用对象,指挥对象做事情。
设计的过程:
其实就是在管理和维护对象之间的关系。
面向对象的特征:
封装(encapsulation)
继承(inheritance)
多态(polymorphism)
其实就是不断的创建对象,使用对象,指挥对象做事情。
设计的过程:
其实就是在管理和维护对象之间的关系。
面向对象的特征:
封装(encapsulation)
继承(inheritance)
多态(polymorphism)
2. 类与对象的关系
使用计算机语言就是不断地在描述现实生活中的事物。
java中描述事物通过类的形式体现,类是具体事物的抽象,概念上的定义。
对象即是该类事物实实在在存在的个体。
java中描述事物通过类的形式体现,类是具体事物的抽象,概念上的定义。
对象即是该类事物实实在在存在的个体。
2.1 类与对象比喻
可以理解为:类就是图纸,汽车就是堆内存中的对象。
对于同一类事物可以抽取它们的共性的内容,定义在类中。如:生活中的汽车,每一台车都有轮胎数和颜色。
那么在通过java描述汽车这类事物时,就可以将这两个共性属性作为类中的属性进行定义。
通过该类建立的每一个汽车实体都具有该属性,并可以有对象特有的属性值。
对于同一类事物可以抽取它们的共性的内容,定义在类中。如:生活中的汽车,每一台车都有轮胎数和颜色。
那么在通过java描述汽车这类事物时,就可以将这两个共性属性作为类中的属性进行定义。
通过该类建立的每一个汽车实体都具有该属性,并可以有对象特有的属性值。
2.3 类的定义
生活中描述事物无非就是描述事物的属性和行为。如:人有身高,体重等属性,有说话,打球等行为。
Java中用类class来描述事物也是如此。
属性:对应类中的成员变量。
行为:对应类中的成员函数。
定义类其实在定义类中的成员(成员变量和成员函数)。
Java中用类class来描述事物也是如此。
属性:对应类中的成员变量。
行为:对应类中的成员函数。
定义类其实在定义类中的成员(成员变量和成员函数)。
2.4 成员变量和局部变量
成员变量:
1. 成员变量定义在类中,在整个类中都可以被访问。
2. 成员变量随着对象的建立而建立,随着对象的消失而消失,存在于对象所在的堆内存中。
3. 成员变量有默认初始化值。
局部变量:
1. 局部变量只定义在局部范围内,如:函数内,语句内等,只在所属的区域有效。
2. 局部变量存在于栈内存中,作用的范围结束,变量空间会自动释放。
3. 局部变量没有默认初始化值。
1. 成员变量定义在类中,在整个类中都可以被访问。
2. 成员变量随着对象的建立而建立,随着对象的消失而消失,存在于对象所在的堆内存中。
3. 成员变量有默认初始化值。
局部变量:
1. 局部变量只定义在局部范围内,如:函数内,语句内等,只在所属的区域有效。
2. 局部变量存在于栈内存中,作用的范围结束,变量空间会自动释放。
3. 局部变量没有默认初始化值。
2.5 创建和使用对象
java中通过new关键字来创建对象
/*
* 描述小汽车
* 分析:
* 1. 属性:
* 轮胎数
* 颜色
* 2. 行为
* 移动
* 定义类其实就是在定义类中的成员。
* 成员:成员变量<-->属性,成员函数<-->行为。
*/
//对Car这类事物进行描述
class Car
{
//成员变量
String color = "red";
int num = 4;
//成员方法,移动
void show()
{
//临时变量
int num = 10;
//输出临时变量的值
System. out.println("color = " +color +"...num = " +num);
}
}
class CarDemo
{
public static void main(String[] args)
{
//通过new关键字,建立对象
//c就是一个类类型的引用变量,指向了该类的对象
Car c = new Car();
//对对象的属性进行修改
c. color = "black" ;
//输出成员变量的默认值
System. out.println(c.num);
//通过对象.成员的形式来使用对象的功能
c.show();
}
}
2.6 对象的内存结构
示例:Car c1 = new Car();
c1.color="blue";
Car c2 = new Car();
内存结构示意图:
只要是用new操作符定义的实体就会在堆内存中开辟一个新的空间,并且每一个对象中都有一份属于自己的属性。
通过(对象 .)对象成员的方式操作对象中的成员,对其中一个对象的成员进行了修改,和另一个对象没有任何关系。
需要提到的是c1、c2都是对实体的引用变量,如果执行c2 = c1,那么c2也就指向了c1引用的实体。c2原来引用的实体因为没 有被引用变量引用,就会被垃圾回收器回收。
2.7 匿名对象
匿名对象是对象的简化形式。
匿名对象两种使用情况:
匿名对象两种使用情况:
1. 当对对象方法仅进行一次调用时;
2. 匿名对象可以作为实际参数进行传递。
示例:
class Car
{
String color = "red";
int num = 4;
public static void run()
{
System.out.println("function run is running!" );
}
}
class CarDemo{
public static void main(String[] args){
//对对象方法仅进行一次调用时,就可以使用匿名对象
new Car().run();
//匿名对象可以作为实际参数进行传递
show(new Car());
}
public static void show(Car c){
c. num = 3;
c. color = "black" ;
System.out.println("function show is running!" );
System.out.println(c.num + "..." + c. color);
}
}
2.8.1 基本数据类型参数
//基本数据类型参数传递
class Demo
{
public static void main(String[] args){
//定义int型数据变量x
<span style="line-height: 30.7999992370605px;"> </span><span style="font-family: SimSun; line-height: 30.7999992370605px;">int x = 3;</span>
show(x);
System.out.println("x=" + x);
}
public static void show(int x)
{
x = 4;
}
}
执行过程说明:
1、jvm调用main方法,main方法入栈。
2、将x变量值设置为3。
3、main方法调用show方法,3作为基本数据类型参数赋值给show方法参数x,也就是说,此时show方法的参数x值为3。
4、show方法执行x=4后,show方法的参数x值变为4。
5、show方法执行结束,show方法出栈。show方法参数x也随之出栈。
6、main方法打印x的值。此时x指的是main方法中的x变量的值(show方法中的参数x已经随show方法一块出栈了)。所以,打印出来的x值为3而 不是4。
7、main方法执行结束,出栈。
2.8.2 引用数据类型参数
class Demo
{
int x = 3;
public static void main(String[] args)
{
//定义引用数据类型
Demo d = new Demo();
d.x = 9;
//这里d是一个引用数据类型,它只向了一个对象。
show(d);
System.out.println(d.x);
}
public static void show(Demo d)
{
d.x = 4;
}
}
执行过程说明:
1、jvm调用main方法,main方法入栈。
2、创建Demo对象d(在堆内存中创建,d作为引用变量,指向堆内存中创建的实体对象),并将d指向的实体对象中的属性x的值设置为9。
3、main方法调用show方法,d作为引用数据类型参数赋值给show方法参数d,也就是说,此时show方法的参数d和main方法中的变量d同时指向了 堆内存中同一个实体对象。
4、show方法执行d.x=4后,堆内存中的实体对象的x属性值变为4。
5、show方法执行结束,show方法出栈,show方法参数d也随之出栈。虽然show方法参数d出栈了,但是,由于main方法的变量d依然引用着堆内存 中的实体对象,因此堆内存中的实体对象不会被垃圾回收器清除。
6、main方法打印d.x的值。此时,d指的是main方法中的引用变量x,d.x指的依然是堆内存中的实体对象中x的值。所以,打印出来的值为4而不 是9。
7、main方法执行结束,出栈。
在java中,方法参数的传递永远都是传值,而这个值,对于基本数据类型,值就是你赋给变量的那个值。而对于引用数据类型,这个值是对 象的引用,而不是这个对象本身。
3. 封装
封装:是指隐藏对象的属性和实现细节,仅对外提供公共访问方式。
好处:
1. 将变化隔离。
2. 便于使用。
3. 提高重用性。
4. 提高安全性。
封装原则:
1. 将不需要对外提供的内容都隐藏起来。
2. 把属性都隐藏,提供公共方法对其访问。如,getXXX,setXXX。
示例:
好处:
1. 将变化隔离。
2. 便于使用。
3. 提高重用性。
4. 提高安全性。
封装原则:
1. 将不需要对外提供的内容都隐藏起来。
2. 把属性都隐藏,提供公共方法对其访问。如,getXXX,setXXX。
/**
* 需求:演示封装特性,定义一个人对象,将人的姓名年龄属性分装。
* 思路:成员参数私有化,对外提供公共方法来修改私有成员变量。
* @author jinlong
* */
package com.blog.part2.对象;
class Person
{
//通过私有化把属性进行隐藏
private String name;
private int age;
//构造函数初始化成员变量值
Person(String name,int age)
{
this.setName(name);
this.setAge(age);
}
//对外提供get,set方法,用来修改和获取name,age值
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public int getAge() {
return age;
}
public void setAge(int age) {
//在set方法内还可以对属性的赋值进行限制
if(age<130&&age>0)
this.age = age;
else
System.out.println("年龄赋值不符合常识!");
}
}
public class PersonDemo {
public static void main(String[] args)
{
//定义一个对象p1,
Person p1 = new Person("zhangsan",20);
//通过get set方法访问
System.out.println("姓名:"+p1.getName()+" 年龄:"+p1.getAge());
//赋值不合法,set方法就不允许成功赋值
p1.setAge(300);
//打印
System.out.println("姓名:"+p1.getName()+" 年龄:"+p1.getAge());
}
}
运行结果:
1、私有仅仅是封装的一种体现而已。
2、private关键字:是一个权限修饰符,用于修饰成员(成员变量和成员函数),被私有化的成员只在本类中有效。
3、常用场景之一:将成员变量私有化,对外提供对应的set、get方法对其进行访问,提高对数据访问的安全性。
4. 构造函数
4.1 特点:
1、函数名与类名相同。
2、不用定义返回值类型。
3、没有具体的返回值。
2、不用定义返回值类型。
3、没有具体的返回值。
作用:给对象进行初始化。
2、创建对象都必须要通过构造函数初始化。
一个类中如果没有定义过构造函数,那么该类中会有一个默认的空参数构造函数。
如果在类中定义了指定的构造函数,那么类中的默认构造函数就没有了。
3、多个构造函数是以重载的形式存在的。
示例:
4.2 与一般函数区别:
1、一般函数和构造函数什么区别呢?
构造函数:对象创建时,就会调用与之对应的构造函数,对对象进行初始化。
一般函数:对象创建后,需要函数功能时才调用。
构造函数:对象创建时,会调用并且只调用一次。
一般函数:对象创建后,可以被调用多次。
一般函数:对象创建后,需要函数功能时才调用。
构造函数:对象创建时,会调用并且只调用一次。
一般函数:对象创建后,可以被调用多次。
2、创建对象都必须要通过构造函数初始化。
一个类中如果没有定义过构造函数,那么该类中会有一个默认的空参数构造函数。
如果在类中定义了指定的构造函数,那么类中的默认构造函数就没有了。
3、多个构造函数是以重载的形式存在的。
/**
* 需求:演示构造函数重载
* @author jinlong
* */
package com.blog.part2.对象;
class Person
{
private String name;
private int age;
//无参数构造函数
Person()
{
name="zhangsan";
age=1;
System.out.println("Person1 run");
}
//有参数构造函数,孩子一出生就命名。
Person(String n)
{
name=n;
System.out.println("Person2 run");
}
//孩子一出生就有名字和年龄
Person(String n,int a)
{
name=n;
age=a;
System.out.println("Person3 run");
}
//定义speak方法来打印本对象的姓名年龄
public void speak()
{
System.out.println(name+":::"+age);
}
//这里省略get set方法
}
public class PersonDemo1
{
public static void main(String[] args)
{
//创建一个孩子
Person p1=new Person();
p1.speak();
//创建一个叫张三的孩子
Person p2=new Person("张三");
p2.speak();
//创建一个叫李四的,三岁的孩子
Person p3= new Person("李四",3);
p3.speak();
}
}
运行结果:
从上边结果可知,构造函数也可以重载,满足不同的对象创建过程。
4.3构造代码块:
可以给所有对象进行初始化,并且构造代码块优先于构造函数执行。
/**
* 需求:演示构造代码块
* @author jinlong
* */
package com.blog.part2.对象;
class Person
{
private String name;
private int age;
//构造代码块,可以给所有对象进行初始化
{
System.out.println("构造代码块运行了");
}
//无参数构造函数
Person()
{
name="zhangsan";
age=1;
}
//有参数构造函数,孩子一出生就命名。
Person(String n)
{
name=n;
}
//孩子一出生就有名字和年龄
Person(String n,int a)
{
name=n;
age=a;
}
//定义speak方法来打印本对象的姓名年龄
public void speak()
{
System.out.println(name+":::"+age);
}
//这里省略get set方法
}
public class PersonDemo1
{
public static void main(String[] args)
{
//创建一个孩子
Person p1=new Person();
p1.speak();
//创建一个叫张三的孩子
Person p2=new Person("张三");
p2.speak();
//创建一个叫李四的,三岁的孩子
Person p3= new Person("李四",3);
p3.speak();
}
}
运行结果:
5. this关键字
this代表其所在函数所属对象的引用。换言之,this代本类对象的引用。
当成员变量和局部变量重名,可以用关键字this来区分,this就是所在函数所属对象的引用。
简单说,哪个对象调用了this所在的函数,this就代表哪个对象。一般方法调用默认加this。
什么时候使用this关键字呢?
当成员变量和局部变量重名,可以用关键字this来区分,this就是所在函数所属对象的引用。
简单说,哪个对象调用了this所在的函数,this就代表哪个对象。一般方法调用默认加this。
什么时候使用this关键字呢?
当在函数内需要用到调用该函数的对象时,就用this。
通常this被用来区分成员变量和局部变量
this还可以用来在构造函数中调用其他构造函数,这时候this在构造函数中被放在第一行。等继承那里还会学 到一个类似的关键字super,也要放在第一行。
示例:
/**
* 需求:this关键字的应用
* @author jinlong
* */
package com.blog.part2.对象;
class Person
{
private String name ;
private int age ;
Person(String name)
{
//通过this区分成员变量和局部变量
this.name = name;
}
Person(String name, int age)
{
//this也可以用于在构造函数中调用其他构造函数
this(name);
this.age = age;
}
public void speak()
{
System.out.println(name + ":" + age);
}
}
class ConsDemo{
public static void main(String[] args)
{
Person p1 = new Person("张三" );
p1.speak();
Person p2 = new Person("李四" ,1);
p2.speak();
}
}
6. static关键字
6.1 定义及特点
static关键字:用于修饰成员(成员变量和成员函数)。
被修饰后的成员具备以下特点:
1、随着类的加载而加载。
2、优先于对象存在。
3、被所有对象所共享。
4、可以直接被类名调用。
被修饰后的成员具备以下特点:
1、随着类的加载而加载。
2、优先于对象存在。
3、被所有对象所共享。
4、可以直接被类名调用。
6.2 成员变量和静态变量的区别
6.2.1 区别
1. 两个变量的生命周期不同
成员变量随着对象的创建而存在,随着对象被回收而释放。
静态变量随着类的加载而存在,随着类的消失而消失。
2. 调用方式不同
成员变量只能被对象调用。
静态变量可以被对象调用,还可以被类名调用。
3. 别名不同
成员变量也称为实例变量。
静态变量也称为类变量。
4. 数据存储位置不同
成员变量存储在堆内存的对象中,所以也叫对象的特有数据。
静态变量数据存储在方法区(共享数据区)的静态区,所以也叫对象的共享数据。
1. 静态方法只能访问静态成员,如果访问非静态成员,就会报错!成员变量随着对象的创建而存在,随着对象被回收而释放。
静态变量随着类的加载而存在,随着类的消失而消失。
2. 调用方式不同
成员变量只能被对象调用。
静态变量可以被对象调用,还可以被类名调用。
3. 别名不同
成员变量也称为实例变量。
静态变量也称为类变量。
4. 数据存储位置不同
成员变量存储在堆内存的对象中,所以也叫对象的特有数据。
静态变量数据存储在方法区(共享数据区)的静态区,所以也叫对象的共享数据。
6.2.2 使用注意:
原因:静态方法和变量存在的时候,对象还不存在,非静态变量也不存在,肯定无法访问。
2、静态方法中不可以写this,super关键字。
原因:静态方法存在的时候,对象还不存在,this代表的就是调用方法的那个对象,既然不存在,肯定不可以写在静态方法中。
3、主函数是静态的,主函数特殊之处:
1. 格式是固定的。
2. 被jvm所识别和调用。
原因:静态方法存在的时候,对象还不存在,this代表的就是调用方法的那个对象,既然不存在,肯定不可以写在静态方法中。
3、主函数是静态的,主函数特殊之处:
1. 格式是固定的。
2. 被jvm所识别和调用。
主函数各成分解析:
public:权限必须是最大的,被jvm调用。
static:不需要对象调用,直接用主函数所属类名调用即可。 命令行窗口中输入:java StaticDemo,实际上就是在执行 StaticDemo.main();。
void: 主函数不需要具体的返回值。
main: 函数名,不是关键字,只是一个jvm识别的固定的名字。
String[] args:这是主函数的参数列表,是一个数组类型的参数,而且元素都是字符串类型。
public:权限必须是最大的,被jvm调用。
static:不需要对象调用,直接用主函数所属类名调用即可。 命令行窗口中输入:java StaticDemo,实际上就是在执行 StaticDemo.main();。
void: 主函数不需要具体的返回值。
main: 函数名,不是关键字,只是一个jvm识别的固定的名字。
String[] args:这是主函数的参数列表,是一个数组类型的参数,而且元素都是字符串类型。
6.3什么时候使用静态
6.3.1 静态变量
当分析对象中所具备的成员变量的值都是相同时,这时这个成员就可以被静态修饰。只要数据在对象中都是不同的,就是对象的特有数据,必须存储在对象中,是非静态的。
如果是相同的数据,对象不需要做修改,只需要使用即可,不需要存储在对象中,定义成静态的。
/**
* 需求:静态的使用
* @author jinlong
* */
package com.blog.part2.对象;
class Person
{
//成员变量,实例变量
String name;
//静态变量,类变量
//所有对象共享的属性用static修饰
static String country = "CN";
public void show()
{
System.out.println(country + ":" + name);
//等效语句:System.out.println(Person.country + ":" + this.name);
}
}
class StaticDemo
{
public static void main(String[] args)
{
Person p = new Person();
System.out.println(p.country);
//可以用类名直接调用
System.out.println(Person.country);
//不管建立多少个对象,country的值都是相同的。
}
}
6.3.2 静态函数
函数是否用静态修饰,就参考一点,就是该函数功能是否需要访问到对象中的特有数据。简单点说,从源代码看,该功能是否需要访问非静态的成员变量,如果需要,该功能就是非静态的。
如果不需要,就可以将该功能定义成静态的。当然,也可以定义成非静态,但是非静态需要被对象调用。
如果没有访问特有数据的方法,该对象的创建是没有意义。
6.3.3 静态代码块
随着类的加载而执行,而且只执行一次。作用:用于给类进行初始化。
6.3.4 工具类
当某个功能类中使用的数据都是用户输入的数据,这是可以考虑让程序更加严谨不建立对象,可以将这个类的方法都定义成静 态的static,直接通过类名调用即可。为了进一步避免该类被建立成对象,可以将构造函数私有化。
示例:
/**
*需求:定义一个工具类,并使用
* @author jinlong
* */
package com.blog.part2.对象;
//定义数组工具类
class ArrayTools
{
//私有话构造函数,禁止创建这个工具类的对象。
private ArrayTools(){};
//将我们前边用过的方法定义静态方法
//对数组进行选择排序
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);
}
}
}
//用于给数组进行元素的位置置换。
private static void swap(int[] arr, int a,int b)
{
int temp = arr[a];
arr[a] = arr[b];
arr[b] = temp;
}
//遍历打印数组方法
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] + "]" );
}
}
}
public class ArrayToolsDemo
{
public static void main(String[] args)
{
//定义数组
int [] arr= {2,5,1,8,6,4,3};
//无需创建工具类对象,直接调用工具类方法
ArrayTools.printArray(arr);
ArrayTools.selectSort(arr);
ArrayTools.printArray(arr);
}
}
运行结果:
7. 单例设计模式
7.1 概述
设计模式:对问题行之有效的解决方式,其实,它是一种思想。
单例设计模式解决的问题:就是可以保证一个类在内存中的对象唯一性。
比如多个程序使用同一个配置信息对象时,就需要保证该对象的唯一性。
单例设计模式解决的问题:就是可以保证一个类在内存中的对象唯一性。
比如多个程序使用同一个配置信息对象时,就需要保证该对象的唯一性。
如何保证对象唯一性呢?
1、不允许其他程序用new创建该类对象。
2、在该类创建一个本类实例。
3、对外提供一个方法让其他程序可以获取该对象。
步骤:
1、私有化该类构造函数。
2、通过new在本类中创建一个本类对象。
3、定义一个公有的方法,将创建的对象返回。
7.2 分类
饿汉式:
/**
* 需求:设计单例设计模式类:饿汉式
* 思路: 之所以不用Single.s;的方式获取Single对象,而采用getInstance获取是因为在getInstance方法中
* 我们可以做一些判断来决定是否返回Single的对象,也就是实现了对单例对象的可控。所以,给
* Single的构造方法加上了private限制,禁止使用者直接采用Single.s;的方式获取。
* @author jinlong
* */
package com.blog.part2.对象;
//单例类
class Single
{
//类已加载,对象就已经存在了
private static Single s = new Single();
private Single(){}
//这里提供静态方法,返回Single对象。
//还可以在这里加入判断语句来控制是否返回Single对象。
public static Single getInstance()
{
return s ;
}
}
class SingleDemo{
public static void main(String[] args){
Single s1 = Single. getInstance();
Single s2 = Single. getInstance();
System.out.println(s1 == s2);
}
}
运行结果为true,s1和s2引用的是同一个对象。
懒汉式:
/**
* 需求:设计单例设计模式类:懒汉式
* 思路: 懒汉式又叫做延迟加载,原理就是类加载时,还没有建立对象,
* 存在延迟,只有当调用静态方法时才会创建该类的对象。
* @author jinlong
* */
package com.blog.part2.对象;
//单例类
class Single
{
//类加载进来,没有对象,只有调用了getInstance方法时,才会创建对象
//延迟加载形式
private static Single s = null;
private Single(){}
//这里提供静态方法,返回Single对象。
//还可以在这里加入判断语句来控制是否返回Single对象。
public static Single getInstance()
{
return s ;
}
}
class SingleDemo{
public static void main(String[] args){
Single s1 = Single. getInstance();
Single s2 = Single. getInstance();
System.out.println(s1 == s2);
}
}