一、面向对象概述
1、理解面向对象: a、面向对象是相对面向过程而言; b、面向对象和面向过程都是一种思想; c、面向过程:强调的是功能行为; d、面向对象:将功能封装进对象,强调具备了功能的对象; e、面向对象是基于面向过程的。面向过程是面向对象的基础。 2、把大象放进冰箱例子: 面向过程描述:打开冰箱,存储大象,关闭冰箱; 面向对象描述:冰箱打开,冰箱存储,冰箱关闭; 3、面向对象将复杂的事情简单化。面向过程到面向对象的转变,人也从执行者变为指挥者的角色。二、面向对象举例
买电脑的例子: 自己买电脑:查资料、咨询、砍价、付款; 请别人买电脑:让别人去买,自己付款就行; 面试的例子: 公司可以把程序员当对象。三、面向对象——类与对象的关系
1、分析一句话中有几个对象可用:名词提炼法 例如: 人开门; 人 //是一个对象 { 开门(门)//调用门的方法 { 门.开(); } } 门 //是一个对象 { 开(){操作门轴等}//调用开的方法 } 2、面向对象的三个特征:封装、继承、多态。 3、开发其实就是在找对象,建立对象,使用对象,并维护对象之间的关系。 4、类和对象之间的关系 学习计算机语言其实就是用计算机语言去描述现实中的事物。 类就是对现实生活中事物的描述; 对象就是这类事物,是实实在在存在的个体。 生活中的对象:张三 李四 描述就是提取对象中的共性内容,就是对具体对象的抽象; 映射到java中,描述就是class定义的类; 具体对象就是对应java在堆内存中用new建立的实体。 4、描述一个事物就是在描述事物的属性和行为。属性对应类中的成员变量,行为对应类中的方法(函数)。 定义类就是在描述事物,就是在定义属性和行为;属性和行为共同成为类中的成员(成员变量和成员函数)。 描述事物的代码体现(示例):class Car { String color = "red"; int num = 4; void run() { System.out.println(color+"..run.."+num); } } class CarDemo { public static void main(String[] args) { //生产汽车,在java中通过new操作符来完成;其实就是在堆内存中产生一个实体。 Car c = new Car();//c就是一个类类型变量;类类型变量指向对象; //在java中,指挥对象做事情的方式是:对象.对象成员; c.color = "blue"; c.run(); c.num = 5; Car c1 = c;//c和c1指向同一个实体 //c1.num=5, c1.color=blue; c1.color = "green"; c.run(); //结果是green..run..5 } }
四、成员变量和局部变量
1、作用范围:
成员变量定义在类中,作用于整个类。
局部变量定义在函数中,作用于函数或者语句中。
2、在内存中的位置:
成员变量:在堆内存中,因对象的存在而存在;
局部变量:存在栈内存中。
3、成员变量都有默认初始化值,局部变量没有默认初始化值。
4、也可以在本类中创建本类对象;class Car { String color = "red"; int num = 4; public void run() { System.out.println(color+"...run..."+num); } public static void main(String[] args) { Car c = new Car(); c.run(); } }
五、匿名对象的应用
1、概念:匿名对象就是没有名字的对象,是对象的简化形式;
例如:class Car { String color = "red"; int num = 4; public void run() { System.out.println(color+"...run..."+num); } public static void main(String[] args) { new Car().num = 5; new Car().color = "blue" ; //读到下面一句话时,上面两句话已经垃圾了。 new Car().run();//结果是: red...run...4 } }
2、匿名对象的两种使用情况:
a、当对对象方法仅进行一次调用时使用;例如: new Car().run();
b、匿名对象可以作为实际参数进行传递;见示例一。
3、注意:
a、匿名对象也可以调用属性,但是没有意义。
b、如果一个对象进行多个成员调用,必须给这个对象起个名字。
示例一:
需求:汽车修配厂。对汽车进行改装,将送来的车都改成黑色、3轮。
代码:class Car { String color = "red"; int num = 4; public void run() { System.out.println(color+"...run..."+num); } } class Demo { public static void main(String[] args) { show(new Car()); } public static void show(Car c) { c.color = "black"; c.num = 3; c.run(); } }
六、面向对象——封装(Encapsulation)概述
1、封装概念:封装是指隐藏对象的属性和实现细节,仅对外提供公共访问方式。
2、封装的好处:
A、将变化隔离;
B、便于使用;
C、提高重用性;
D、提高安全性。
3、封装原则:
A、将不需要对外提供的内容都隐藏起来;
B、把属性都隐藏,提供公共方法对其访问。
4、函数是java中最小的封装体。七、面向对象——封装 private
private: 私有,权限修饰符:用于修饰类中的成员(成员变量和成员函数)。
私有只在本类中有效(只有本类成员才可以访问本类私有成员)。
注意:
当父类中的成员被 private 修饰后,其子类也不可以直接访问;
但是父类中的成员被 protected 修饰时,其子类可以访问。
示例:class Person { private int age;//一个成员通常对外提供两个访问方式,一个设置值set,一个获取值get。 public void setAge(int a)//对外提供访问方式,设置成员。 { //之所以对外提供访问方式,就因为可以在访问方式中加入逻辑判断语句,对访问的数据进行操作,提高代码的健壮性。 if(a>0 && a<130) { age = a ; //speak(); } else System.out.println("非法age"); } 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.setAge(20); p.speak(); } }
注意:封装不是私有,私有仅仅是封装的一种表现形式。八、面向对象——构造函数
构造函数也是类中的成员,是类的成员的另一种体现。
1、特点:
A、函数名与类名相同;
B、不用定义返回值类型(不是 void ; void 是一种返回值,代表没有具体返回结果);
C、不可以写 return 语句;
D、对象一建立,就会调用与之对应的构造函数。
2、作用:
给对应对象进行初始化;示例一;
3、注意:
① 当一个类中没有定义构造函数时,系统会给该类加入一个空参数的构造函数;
② 当在类中自定义了构造函数后,默认构造函数就没有了。
③ 没有构造函数,对象是建立不出来的,因为没有办法初始化。
4、注意:
A、默认构造函数的特点(见上文);
B、多个构造函数是以重载的形式存在的。示例二。
C、构造函数与一般函数的区别:
构造函数是在对象一建立就运行,给对象初始化;
一般函数是在对象调用时才执行,是给对象添加对象具备的功能;
一个对象建立,构造函数只运行一次,不能被对象再次调用;而一般方法可以被该对象调用多次。
D、什么时候定义构造函数?
当分析事物时,该事物存在具备一些特性或者行为,那么将这些内容定义在构造函数中。
示例一:class Person { //Person(){}//默认的构造函数。 Person() { System.out.println("person run"); } } class PersonDemo { public static void main(String[] args) { Person p = new Person();//结果打印person run; 因为对象一建立,就会调用与之对应的构造函数。 new Person();//结果还是person run } }
示例二:class PersonDemo { public static void main(String[] args) { Person p1 = new Person(); //p1.Person();//不能调用 Person p2 = new Person("zhangsan"); Person p3 = new Person("lisi",12); p3.cry(); p3.setName("wangwu"); System.out.println(p3.getName()); } } class Person { private String name; private int age; Person() { System.out.println("A: name="+name+", age="+age); cry(); } Person(String n) { name = n; System.out.println("B: name="+name+", age="+age); cry(); } 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..."); } public void setName(String n) { name = n; } public String getName() { return name; } }
九、面向对象——构造代码块
1、作用:给对象进行初始化;
2、特点:对象一建立就运行,而且优先于构造函数执行。
3、构造代码块和构造函数的区别:
构造代码块是给所有对象进行统一初始化;而构造函数是给对应对象初始化。
4、应用:
构造代码块用于定义对象的共性内容。
5、注意:
如果构造函数被 private 修饰,则该构造函数不能用来创建对象。
示例一:class Person { {//构造代码块 System.out.println("gouzaodaimakuai"); } Person() { System.out.println("person run"); } }
示例二:class PersonDemo { public static void main(String[] args) { Person p1 = new Person(); Person p2 = new Person("zhangsan"); Person p3 = new Person("lisi",12); } } class Person { private String name; private int age; {//构造代码块 //System.out.println("gouzaodaimakuai"); cry(); } Person() { System.out.println("A: name="+name+", age="+age); //cry(); } Person(String n) { name = n; System.out.println("B: name="+name+", age="+age); //cry(); } 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..."); } public void setName(String n) { name = n; } public String getName() { return name; } }
十、面向对象—— this 关键字
this:
代表本类对象。
代表其所在函数所属对象的引用。简单说:哪个对象在调用 this 所在的函数, this 就代表哪个对象。
示例:结论:成员之间调用都是通过对象来完成的。class Person { private String name; private int 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(); }//此处this.可以省略 public void showName() { System.out.println(this.name);//此处this.可以省略 } }
十一、面向对象——this关键字的应用
this 的应用:
当定义类中的函数,该函数内部要用到调用该函数的对象,这时就用 this 关键字来表示这个对象。
但凡本类功能内部使用到了本类对象,都用 this 表示。
需求:给人定义一个用于比较年龄是否相同的功能。
代码:class PersonDemo { public static void main(String[] args) { Person p1 = new Person(20); Person p2 = new Person(22); boolean bl = p1.compare(p2); System.out.println(bl); } } class Person { private int age; Person(int age) { this.age = age; } public boolean compare(Person p) { return this.age==p.age; }//此时,this和p1指向了同一个对象。 }
十二、this关键字在构造函数间调用
this 语句:用于构造函数之间互相调用。
this();这就是this语句。
注意:
1、构造函数间调用只能用 this 语句;
2、 this 语句只能定义在构造函数的第一行。因为初始化动作要先执行;如果初始化中还有初始化,也就先执行更细节初始化;
3、一般函数不能直接调用构造函数。因为 this 语句不能用在一般函数中,只能用在构造函数中。
结论:
this 关键字的两种用法:
一是用于区分同名变量(成员和局部同名),二是用于构造函数间调用。
代码:class PersonDemo13 { public static void main(String[] args) { Person p = new Person("lisi",20); p.speak(); } /* 运行结果: none name name...age name=lisi, age=20 */ } class Person { private String name; private int age; Person() { System.out.println("none"); } Person(String name) { this();//注意:这条语句和后期说是super();语句不一样,this();语句不是隐式的,不写就没有 this.name = name; System.out.println("name"); } Person(String name, int age) { //this.name = name;//以前的写法 //this语句只能放在构造函数的第一行。 this(name);//p(name); //Person(name);//但是构造函数间不能这样调用。 this.age = age; System.out.println("name...age"); } void speak() { //this();this语句只能用于构造函数中,不能用在一般函数中。 System.out.println("name="+name+", age="+age); } }