——- android培训、java培训、期待与您交流! ———-
面向对象
一、面向对象概念
1.理解面向对象
- 面向对象是相对面向过程而言
- 面向对象和面向过程都是一种思想
- 面向过程:强调的是功能行为
- 面向对象:将功能封装进对象,强调具备了功能的对象。
- 面向对象是基于面向过程的。
2.面向对象的特点
- 是一种符合人们思考习惯的思想
- 可以将复杂的事情简单化
- 将程序员从执行者转换成了指挥者
- 完成需求任务时,要先去找具有所需功能的对象来用。如果该对象不存在,那么创建一个具有所需功能的对象,这样就可以简化开发并且提高程序的复用性。
3.面向对象开发,设计,特征
- 开发的过程其实就是不断的创建对象,使用对象和指挥对象做事情。
- 设计的过程其实就是在管理和维护对象之间的关系。
- 面向对象有三大特征,分别是:封装,集成和多态。
二、类与对象的关系
1.类与对象
- 使用计算机语言就是不断的在描述现实生活中的事物。
- java中描述食物通过类的形式体现,类是具体事务的抽象,概念上的定义。
- 对象即是该类事物实实在在存在的个体。
例如,如果把汽车图纸比作类,那么汽车就是堆内存中的对象,可以有各种各样颜色的汽车。
2.类的定义
- 生活中描述事务无非就是描述事务的属性和行为。在Java中用类(class)来描述事物也是如此。所以类可以定义为属性和行为的集合。
- 属性就是对应类中的成员变量。
- 行为就是对应类中的成员函数或方法。
- 定义类其实就是在定义类中的成员变量和成员函数。
3.成员变量和局部变量的区别
- 成员变量是定义在类中,在整个类中都可以被访问。它随着对象的建立而建立,存在于对象所在的堆内存中。成员变量有默认初始化值。
- 局部变量值定义在局部范围内。例如函数内,语句内,for循环内等等。局部变量存在于栈内存中。作业的范围结束,变量空间会自动释放。局部变量没有默认初始化值。
4.创建对象,使用对象
class Car
{
String color = "red";
int num = ;
void show()
{
System.out.println("Color="+ color+" num"+ num);
}
}
class CarDemo
{
public static void main(String[] args)
{
Car c = new Car();
c.color = "black";
c.show();
}
}
5.对象内存结构
6.匿名对象
- 匿名对象是对象的简化形式。它的使用情况有两种:第一,当对象方法进进行一次调用的时候,可以用匿名对象来完成,这样写比较简化。如果对一个对象进行多个成员调用,必须给这个对象起个名字。第二,匿名对象可以作为实际参数进行传递。
三、封装
1.封装的概念
封装是指隐藏对象是属性和实现细节,仅仅对外提供公共访问方式。举例如下:
class Person
{
private String name;
private int age;
private static String country = "cn";
Person(String name,int age)
{
this.name = name;
this.age = age;
}
public void setName(String name)
{
this.name = name;
}
public void speak()
{
System.out.println(this.name+"..."+this.age);
}
public static void showCountry()
{
System.out.println("country="+country);
}
}
2.封装的好处
- 将变化隔离
- 便于使用
- 提高重用性
- 提高安全性
3.封装的原则
- 将不需要对外提供的内容都隐藏起来,例如
private String name; private int age; private static String country = "cn";
- 把属性都隐藏,仅仅提供公共方法对其访问。正如上例所示,setName(),speak()。
四、构造函数
1.特点
- 函数名与类名相同
- 不用定义返回值类型
- 不可以写return语句
2.作用
给对象进行初始化。对于上例,初始化动作为。
Person p = new Person("Mike","22");
3.注意事项
- 当一个类中没有定义构造函数时,那么系统会默认给该类加入一个空参数的构造函数。当在类中自定义了构造函数后,默认的构造函数就没有了。
- 构造函数和一般函数在写法上有不同。在运行上也有不同。构造函数是在对象一建立就运行。给对象初始化。而一般方法是对象调用才执行,给是对象添加对象具备的功能。一个对象建立,构造函数只运行一次。而一般方法可以被该对象调用多次。
- 什么时候定义构造函数呢?当分析事物时,该事物存在具备一些特性或者行为,那么将这些内容定义在构造函数中。
4.构造代码块
- 作用:给对象进行初始化。对象一建立就运行,而且优先于构造函数执行。
-
和构造函数的区别:
构造代码块是给所有对象进行统一初始化,而构造函数是给对应的对象初始化。构造代码快中定义的是不同对象共性的初始化内容。举例如下
class Person
{
private String name;
private int age;
{
//System.out.println("person code run");
cry();
}
Person()
{
System.out.println("A: name="+name+",,age="+age);
}
/**/
Person(String n)
{
name = n;
System.out.println("B: name="+name+",,age="+age);
//cry();
}
/*
public void setName(String n)
{
name = n;
}
public String getName()
{
return name;
}
*/
Person(String n,int a)
{
name = n;
age = a;
System.out.println("C: name="+name+",,age="+age);
//cry();
}
public void cry()
{
System.out.println("cry......");
}
}
class PersonDemo2
{
public static void main(String[] args)
{
Person p1 = new Person();
Person p2 = new Person("lisi");
//System.out.println(p2.getName());
//Person p3 = new Person("wnagu",10);
}
}
五、this关键字
this:看上去,是用于区分局部变量和成员变量同名情况。
this为什么可以解决这个问题?
this到底代表的是什么呢?
this:就代表本类的对象,到底代表哪一个呢?
this代表它所在函数所属对象的引用。
简单说:哪个对象在调用this所在的函数,this就代表哪个对象。
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 p)
{
return this.age==p.age;
}
}
除此之外,还要注意this语句,即this();
this语句 :用于构造函数之间进行互相调用。
this语句只能定义在构造函数的第一行。因为初始化要先执行。
六、static关键字
静态:static。
用法:是一个修饰符,用于修饰成员(成员变量,成员函数).
当成员被静态修饰后,就多了一个调用方式,除了可以被对象调用外,还可以直接被类名调用。类名.静态成员。
static特点:
1,随着类的加载而加载。也就说:静态会随着类的消失而消失。说明它的生命周期最长。
2,优先于的对象存在明确一点:静态是先存在。对象是后存在的。
3,被所有对象所共享
4,可以直接被类名所调用。
实例变量和类变量的区别:
1,存放位置。
类变量随着类的加载而存在于方法区中。
实例变量随着对象的建立而存在于堆内存中。
2,生命周期:
类变量生命周期最长,随着类的消失而消失。
实例变量生命周期随着对象的消失而消失。
静态使用注意事项:
1,静态方法只能访问静态成员。
非静态方法既可以访问静态也可以访问非静态。
2,静态方法中不可以定义this,super关键字。
因为静态优先于对象存在。所以静态方法中不可以出现this。
3,主函数是静态的。
静态有利有弊
利处:对对象的共享数据进行单独空间的存储,节省空间。没有必要每一个对象中都存储一份。可以直接被类名调用。
弊端:生命周期过长。访问出现局限性。(静态虽好,只能访问静态。)
实例如下:
class Person
{
String name;//成员变量,实例变量。
static String country = "CN";//静态的成员变量,类变量。
public static void show()
{
System.out.println("::::");
this.haha();
}
public void haha()
{}
}
class StaticDemo
{
public static void main(String[] args)
{
Person p = new Person();
//p.name = "zhangsan";
//p.show();
//System.out.println(p.country);
//System.out.println(Person.country);
Person.show();
}
}
七、单例设计模式
设计模式:解决某一类问题最行之有效的方法。
java中23种设计模式:
单例设计模式:解决一个类在内存只存在一个对象。
想要保证对象唯一。
1,为了避免其他程序过多建立该类对象。先禁止其他程序建立该类对象
2,还为了让其他程序可以访问到该类对象,只好在本类中,自定义一个对象。
3,为了方便其他程序对自定义对象的访问,可以对外提供一些访问方式。
这三步怎么用代码体现呢?
1,将构造函数私有化。
2,在类中创建一个本类对象。
3,提供一个方法可以获取到该对象。
对于事物该怎么描述,还怎么描述。
当需要将该事物的对象保证在内存中唯一时,就将以上的三步加上即可。
示例如下:
class Single
{
private Single(){}
private static Single s = new Single();
public static Single getInstance()
{
return s;
}
}
class SingleDemo
{
public static void main(String[] args)
{
Single s1 = Single.getInstance();
Single s2 = Single.getInstance();
s1.setNum();
System.out.println(s2.getNum());
// Single s1 = new Single();
// Single s2= new Single();
// s1.setNum(30);
// System.out.println(s2.getNum());
// Student s1 = new Student();
// s1.setAge(30);
//
// Student s2 = new Student();
// s2.setAge(12);
Student s1 = Student.getStudent();
Student s2 = Student.getStudent();
}
}
class Student
{
private int age;
private static Student s = new Student();
private Student(){}
public static Student getStudent()
{
return s;
}
public void setAge(int age)
{
this.age = age;
}
public int getAge()
{
return age;
}
}