概念:是相对面向过程而言
面向对象和面向过程都是一种思想
面向过程:强调的是功能行为
面向对象:将功能封装进对象,强调具备了功能的对象
面向对象是基于面向过程的
人开门:名词提炼法
人
{
开门(门)
{
门.开();
}
}
门
{
开(){操作门轴等。}
}
再来几个例子方便理解:
面向对象设计把握一个重要的经验:谁拥有数据,谁就对外提供操作这些数据的方法。
再牢牢记住几个案例:人在黑板上画圆 person,blackboard,circle
draw() //是circle的方法
{
x,y—>circle
}
列车司机紧急刹车 //刹车也是车的方法,人只是发布命令让车刹车
售票员正在统计售货小票的金额 //统计金额也是小票的方法
“两块石头磨成一把石刀,石刀可以砍树,砍成木材,木材做成椅子”
Stone //石头不能提供方法把自己变没了
···StoneKnife = KnifeFactory.createKnife(stone);
StoneKnife
···Material = StoneKnife.cut(tree)
Tree
···Chair = ChairFactory.makeChair(material)
Chair
面向对象:三个特征:封装、继承、多态。
以后开发:其实就是找对象使用。没有对象,就创建一个对象
找对象,建立对象,使用对象。维护对象的关系。
类和对象的关系:
类就是:对现实生活中事物的描述。
对象是:这类事物,实实在在存在的个体。
现实生活中的对象:张三 李四
想要描述:提取对象中共性内容。对具体的抽象
描述时:这些对象的共性有:姓名,年龄,性别,学习java功能。
映射到java中,就是class定义的类。
具体对象就是对应java在堆内存中用new建立的实体。
属性对应是类中变量,行为对应的类中的函数(方法)
其实定义类,就是在描述事物,就是在定义属性和行为。属性和行为共同称为类中的成员(成员变量,成员方法)。
作用范围:
成员变量:成员变量作用于整个类中
局部变量:局部变量作用于函数中或语句中
在内存中的位置:
成员变量:在堆内存中,因为对象的存在,才在内存中存在
局部变量:存在栈内存中
匿名对象
匿名对象使用方式之一:当对对象的方法只调用一次时,可以用匿名对象来完成,这样写比较简化
如果对一个对象进行多个成员调用,必须给这个对象起个名字
匿名对象使用方式之二:可以将匿名对象作为实际参数进行传递。
封装:是指隐藏对象的属性和实现细节,仅对外提供公共访问方式
好处:将变化隔离、便于使用、提高重用性、提高安全性。
封装原则:将不需要对外提供的内容都隐藏起来,把属性都隐藏,提供公共方法对其访问
/*
private:私有,权限修饰符:用于修饰符类中的成员(成员变量,成员函数)
将age私有化以后,类以外即使建立了对象也不能直接访问
但是人应该有年龄,就需要在Person类中提供对应访问age的方式
注意:私有仅仅是封装的一种表现形式。
之所以对外提供访问方式,就因为可以在访问方式中加入逻辑判断等语句
对访问的数据进行操作。提高代码健壮性。
*/
class Person
{
private String name;
private int age;
//对不同函数进行初始化
Person()
{
System.out.println("A:name = "+ name+",,age = "+age);
}
Person(String 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);
}
}
class Demo
{
public static void main(String[] args)
{
Person p = new Person();
p.setAge(20);
p.speak();
}
}
构造函数:
1、函数名与类名相同
2、不用定义返回值类型
3、不可以写return语句
作用:
给对象进行初始化。
注意:
1、默认构造函数的特点。
2、多个构造函数时以重载的形式存在的
对象一建立就会调用与之对应的构造函数、
构造函数的作用:可以用于给对象进行初始化。
this :看上去,是用于区分局部变量和成员变量同名的情况
this为什么可以解决这个问题?
this到底代表的是什么呢?
this:就代表本类的对象
this代表它所在函数所属对象的引用。
简单说:哪个对象调用this所在的函数,this就代表哪个对象
this的应用:当定义类中功能时,该函数内部要用到调用该函数的对象时,这时用this来表示这个对象
this 语句只能定义在第一行
/*
需求:给人定义一个用于比较年龄是否相同的功能,也就是是否是同龄人
*/
class Person
{
private String name;
private int age;
Person(String name)
{
this.name = name;
}
Person(int age)
{
this.age = age;
}
Person(String name,int age)
{
//this.name = name;
//this.age = age;
this(name);
this.age = age;
}
public void speak()
{
System.out.println("neme="+name+"....age="+age);
}
public boolean compare(Person p)
{
return this.age == p.age;
}
}
class Demo2
{
public static void main(String[] args)
{
Person p1 = new Person(20);
Person p2 = new Person(19);
boolean b = p1.compare(p2);
System.out.println(b);
}
}
static(静态) 关键字
/*
/*
静态:static
用法:是一个修饰符,用于修饰成员(成员变量)
静态修饰内容被对象所共享
当成员被静态修饰后,就多了一个调用方式,除了被对象调用外,还可以直接被类名调用
类名.静态成员 Person.country
static特点:
1、随着类的加载而加载
也就是:静态会随着类的消失而消失,生命周期最长
2、优先于对象存在
明确一点:静态是先存在,对象是后存在
3、被所有对象所共享
4、可以直接被类名所调用
实例变量和类变量的区别:
1、存放位置:
类变量随着类的加载而存在于方法区中
实例变量随着对象的建立而存在于堆内存中
2、生命周期:
类变量生命周期最长,随着类的消失而消失。
实例变量生命周期随着对象的消失而消失
静态使用注意事项:
1、静态方法只能访问静态成员。
非静态方法可以访问静态成员
2、静态方法中不可以定义this、super关键字
因为静态优先于对象存在。所以静态方法中不可以出现this
优点:对对象的共享数据进行单独空间的存储,节省空间,没有必要每一个对象中都存储一份
可以直接被类名调用
缺点:生命周期过长
主函数时静态的
*/
class Person
{
String name;
static String country = “CN”;
public void show()
{
System.out.println(name+”::”+country);
}
}
class Demo
{
public static void main(String[] args)
{
//Person p = new Person();
//p.name = “zhangsan”;
//p.show();
System.out.println(Person.country);
}
}
*/
/*
/*
public static void main(String[] args)
主函数:是一个特殊函数,作为程序的入口,可以被jvm调用
主函数的定义:
public:代表着该函数访问权限是最大的。
static:代表主函数随着类的加载就已经存在了。
void:主函数没有具体的返回值。
main不是关键字,但是是一个特殊的单词,可以被jvm识别
函数的参数:(String[] args):函数的参数,参数类型是一个数组,该数组中
的元素是字符串,字符串类型的数组。
主函数是固定格式的:jvm识别。
jvm在调用主函数时,传入的是new String[0]
*/
/*
什么时候使用静态?
要从两方面下手:
因为静态修饰的内容有成员变量和函数。
什么时候定义静态变量(类变量)呢?
当对象中出现共享数据时,该数据被静态所修饰
对象中的特有数据要定义成非静态存在于堆内存中
什么时候定义静态函数?
当功能内部没有访问到非静态数据(对象的特有数据)
那么该功能可以定义成静态的
*/
/*
一个类中默认会有一个空参数的构造函数。
这个默认的构造函数的权限和所属类一致
如果类被public修饰,那么默认的构造函数也带public修饰符
如果类没有被public修饰,那么默认的构造函数,也没有public修饰
静态代码块、构造代码块、构造函数同时存在时的执行顺序:静态代码块 –>构造代码块 –> 构造函数;
成员变量先于构造代码块