第一章 面向对象-类与对象
面向对象基础---类与对象
- 面向对象思想概述及举例
- 类与对象及其使用
- 对象的内存图
- 成员变量和局部变量的区别
- 封装(private)
- this关键字
- 构造方法
- 类名作为形式参数和返回值
单词学习
Class 类
Object 对象
Static 静态的
Final：最终的
Private： 私有的
Public: 公有的
Protect:受保护的
Mouse:老鼠、鼠标
Health: 健康
Love:
面向过程思想概述
面向对象基于面向过程
- 我们回想一下，如果我们完成一个需求的步骤：
首先是搞清楚我们要做什么，然后在分析怎么做，最后我们再代码体现。一步一步去实现，而具体的每一步都需要我们去实现和操作。这些步骤相互调用和协作，完成我们的需求。
- 在上面的每一个具体步骤中我们都是参与者，并且需要面对具体的每一个步骤和过程，这就是面向过程最直接的体现。
- 那么什么是面向过程开发呢?
面向过程开发，其实就是面向着具体的每一个步骤和过程，把每一个步骤和过程完成，然后由这些功能方法相互调用，完成需求。
- 面向过程的代表语言：C语言
- 当需求单一，或者简单时，我们一步一步去操作没问题，并且效率也挺高。
可随着需求的更改，功能的增多，发现需要面对每一个步骤很麻烦了，这时就开始思索，能不能把这些步骤和功能在进行封装，封装时根据不同的功能，进行不同的封装，功能类似的封装在一起。这样结构就清晰了很多。用的时候，找到对应的类就可以了。这就是面向对象的思想。
面向对象思想特点及举例
|
package com.obtk_01; /* * 面向对象思想： * 面向对象是基于面向过程的编程思想。 * * 面向过程：强调的是每一个功能的步骤 * 面向对象：强调的是对象，然后由对象去调用功能 * * 面向对象的思想特点： * A:是一种更符合我们思考习惯的思想 * B:可以将复杂的事情简单化 * C:将我们从执行者变成了指挥者 * * 举例： * 买电脑： * 面向过程：我要买电脑--我要明确买电脑的意义--上网查对应的参数信息--去中关村买电脑--讨价还价--买回电脑 * 面向对象：我要买电脑—同学去给我买电脑--买回电脑 * 洗衣服： * 面向过程：把衣服脱下来--找一个盆--放点洗衣粉--加点水--浸泡10分钟--揉一揉--清洗衣服--拧干--晾起来 * 面向对象：把衣服脱下来--打开全自动洗衣机--扔衣服--按钮--晾起来 */ public class Demo {
} |
|
package com.obtk_01; /* * 我们学习编程语言，其实就是为了把现实世界的事物模拟出来，实现信息化。 * * 我们是如何表示现实世界的事物的呢? * A:属性 就是事物的描述信息 * B:行为 就是事物能够做什么 * 举例：学生 * * Java语言最基本的单位是类，所以，我们在后面的学习过程中，是通过类来体现现实世界事物的。 * * 类：是一组相关的属性和行为的集合 * 对象：就是该事物的具体体现 类和对象的关联关系：对象是类的实例 ，类是对象的模板 * 举例： * 类 学生 * 对象 班长 */ public class Demo2 {
} |
类与对象的关系
- 我们学习编程语言，就是为了模拟现实世界的事物，实现信息化。比如：去超市买东西的计费系统，去银行办业务的系统。
- 我们如何表示一个现实世界事物呢：
– 属性 就是该事物的描述信息
– 行为 就是该事物能够做什么
– 举例：学生事物
- 我们学习的Java语言最基本单位是类，所以，我们就应该把事物用一个类来体现。
- 类：是一组相关的属性和行为的集合
- 对象：是该类事物的具体体现
- 举例：
– 类 学生
– 对象 班长就是一个对象
类的定义
- 现实世界的事物
– 属性 事物的描述信息
– 行为 事物能做什么
– Java中用class描述事物也是如此
– 成员变量 就是事物的属性
– 成员方法 就是事物的行为
- 定义类其实就是定义类的成员(成员变量和成员方法)
|
1:成员变量 和以前定义变量是一样的，只不过位置发生了改变。在类中，方法外。 2:成员方法 和以前定义方法是一样的，只不过把static去掉，面向对象进阶在详细讲解static的作用。 |
学生类和学生的对应关系(编写学生类com.obtk_02.Student)
|
package com.obtk_02; /* * 类的定义： * 类是用来描述现实世界的事物的 * * 事物： * 属性 事物的描述信息 * 行为 事物能够做什么 * * 类是如何和事物进行对应的呢? * 类： * 成员变量 * 成员方法 * * 需求：写一个学生类 * * 学生事物： * 属性：姓名，年龄... * 行为：学习，吃饭... * * 学生类： * 成员变量：姓名,年龄 * 成员方法：学习,吃饭 * * 成员变量：和我们前面学习过的变量的定义是一样的。 * 位置不同：成员变量在类中，方法外 前面学的变量在方法里或方法声明上 * 初始化值：不需要给初始化值 因为成员变量有默认值 * 成员方法：和我们前面学习过的方法的定义是一样的。 * 去掉static关键字 */ public class Student { //成员变量 //姓名 String name; //年龄 int age;
//成员方法 //学习的方法 public void study() { System.out.println("好好学习，天天向上"); }
//吃饭的方法 public void eat() { System.out.println("学习饿了要吃饭"); } } |
创建学生测试类(使用学生类com.obtk_02.StudentDemo)
|
package com.obtk_02; /* * Student是一个学生事物描述类，main方法不适合放在它里面。 * * 使用一个类，其实就是使用该类的成员。(成员变量和成员方法) * 而我们要想使用一个类的成员，就必须首先拥有该类的对象。 * 我们如何拥有一个类的对象呢? * 创建对象就可以了? * 我们如何创建对象呢? * 格式：类名 对象名 = new 类名(); * 对象如何访问成员呢? * 成员变量：对象名.变量名 * 成员方法：对象名.方法名(...) */ public class StudentDemo { public static void main(String[] args) { //格式：类名 对象名 = new 类名(); Student s = new Student(); //System.out.println("s:"+s); //输出结果为：com.obtk_02.Student@193c0cf 193c0cf：地址值 因为Student是我们new出来的，new出来的东西在我们的堆内存，堆内存就有地址值。
//直接输出成员变量值 System.out.println("姓名："+s.name); //结果：null 因为name是字符串类型而字符串是个引用类型，因为字符串是个类，引用类型的默认值是null System.out.println("年龄："+s.age); //0 age是int类型，int类型默认值为0 这是堆内存的默认值 System.out.println("----------");
//给成员变量赋值 s.name = "林青霞"; s.age = 28;
//再次输出成员变量的值 System.out.println("姓名："+s.name); //林青霞 System.out.println("年龄："+s.age); //28 System.out.println("----------");
//调用成员方法 s.study(); s.eat(); } } |
类与对象的案例
- 学生类(讲解)
– 如何定义
- 按照事物到类的过程一步步分析
– 如何使用
- 创建对象：
– 类名 对象名 = new 类名();
- 对象名.成员变量
- 对象名.成员方法
- 手机类练习
手机类的定义和使用(创建类：com.obtk_02. Phone)
以后我们编写描述类的时候，没必要编写事物，我们直接写类的成员变量、成员方法就可以了。
|
package com.obtk_02; /* * 手机类： * 成员变量：品牌，价格，颜色... * 成员方法：打电话，发短信... */ public class Phone { //品牌 String brand; //价格 int price; //颜色 String color;
//打电话 public void call(String name) { System.out.println("给"+name+"打电话"); }
//发短信 public void sendMessage() { System.out.println("群发短信"); } } |
手机类的测试类（创建类：com.obtk_02. PhoneDemo)
|
package com.obtk_02; /* * 手机类的测试类 */ public class PhoneDemo { public static void main(String[] args) { //创建对象 Phone p = new Phone();
//输出成员变量值 System.out.println("品牌："+p.brand);//null System.out.println("价格："+p.price);//0 System.out.println("颜色："+p.color);//null System.out.println("------------");
//给成员变量赋值 p.brand = "锤子"; p.price = 2999; p.color = "棕色";
//再次输出成员变量值 System.out.println("品牌："+p.brand);//锤子 System.out.println("价格："+p.price);//2999 System.out.println("颜色："+p.color);//棕色 System.out.println("------------");
//调用成员方法 p.call("林青霞"); p.sendMessage(); } } |
成员变量和局部变量的区别(创建类：Com.obtk_03.Variable)
|
package com.obtk_03; /* * 成员变量和局部变量的区别： * A:在类中的位置不同 * 成员变量：类中，方法外 * 局部变量：方法中或者方法声明上(形式参数) * B:在内存中的位置不同 * 成员变量：堆内存 * 局部变量：栈内存 * C:生命周期不同 * 成员变量：随着对象的创建而存在，随着对象的消失而消失 * 局部变量：随着方法的调用而存在，随着方法的调用完毕而消失 * D:初始化值的问题 * 成员变量：有默认值 * 局部变量：没有默认值。必须先定义，赋值，最后使用 */ public class Variable { int x; public void show() { int y = 0; System.out.println(x); System.out.println(y); } } |
private关键字
- private关键字：
– 是一个权限修饰符。
– 可以修饰成员(成员变量和成员方法)
– 被private修饰的成员只在本类中才能访问。
– private最常见的应用：
– 把成员变量用private修饰
– 提供对应的getXxx()/setXxx()方法
– 一个标准的案例的使用
Get:获取 set:赋值
private关键字的由来及使用
com.obtk_04.Student
|
package com.obtk_04; /* * 学生类 * * 通过对象直接访问成员变量，会存在数据安全问题 * 这个时候，我们就想能不能不让外界的对象直接访问成员变量呢? * 能。 * 如何实现呢? * private关键字 * * private: * 是一个修饰符 * 可以修饰成员变量，也可以修饰成员方法 * 被private修饰的成员只能在本类中被访问 * * 针对private修饰的成员变量，我们会相应的提供getXxx()和setXxx()用于获取和设置成员变量的值,方法用public修饰 */ public class Student { String name; //int age; private int age;
public void setAge(int a) { if(a<0 || a>200) { System.out.println("你给的年龄有误"); }else { age = a; } }
public int getAge() { return age; }
public void show() { System.out.println("姓名是："+name+",年龄是："+age); } } |
com.obtk_04.StudentDemo
|
package com.obtk_04; /* * 学生类的测试类 */ public class StudentDemo { public static void main(String[] args) { //创建学生对象 Student s = new Student(); s.show();
s.name = "林青霞"; //s.age = 28; //s.age = -28; //s.setAge(-28); s.setAge(28); s.show(); } } |
成员变量修饰符：书p32
public（公共访问控制符），指定该变量为公共的，他可以被任何对象的方法访问。
private（私有访问控制符）指定该变量只允许自己的类的方法访问，其他任何类（包括子类）中的方法均不能访问。
protected（保护访问控制符）指定该变量可以别被自己的类和子类访问。在子类中可以覆盖此变量。
friendly ，在同一个包中的类可以访问，其他包中的类不能访问。
final，最终修饰符，指定此变量的值不能变。
static（静态修饰符）指定变量被所有对象共享，即所有实例都可以使用该变量。变量属于这个类。
transient（过度修饰符）指定该变量是系统保留，暂无特别作用的临时性变量。
volatile（易失修饰符）指定该变量可以同时被几个线程控制和修改。
成员变量的私有的标准代码
package com.obtk_05. Student
|
package com.obtk_05; /* * 学生类 */ public class Student { private String name; private int age;
public void setName(String n) { name = n; }
public String getName() { return name; }
public void setAge(int a) { age = a; }
public int getAge() { return age; } } |
package com.obtk_05. StudentDemo
|
package com.obtk_05; /* * 学生类的测试类 */ public class StudentDemo { public static void main(String[] args) { //创建对象 Student s = new Student(); System.out.println(s.getName()+"---"+s.getAge());
s.setName("林青霞"); s.setAge(28); System.out.println(s.getName()+"---"+s.getAge()); } } |
起名字要做到简明知意，n和a不符合我们的命名规范
封装
- 封装概述
– 是面向对象三大特征之一
– 是面向对象编程语言对客观世界的模拟，客观世界里成员变量都是隐藏在对象内部的，外界无法直接操作和修改。就像刚才说的年龄。
- 封装原则：
– 将不需要对外提供的内容都隐藏起来。
– 把属性隐藏，提供公共方法对其访问。
- 成员变量private，提供对应的getXxx()/setXxx()方法
- 好处：
– 通过方法来控制成员变量的操作，提高了代码的安全性
– 把代码用方法进行封装，提高了代码的复用性
this关键字
- this:代表所在类的对象引用
- 记住：
– 方法被哪个对象调用，this就代表那个对象
- 什么时候使用this呢?
成员变量和局部变量同名，在同一个方法里
局部变量隐藏成员变量 com.obtk_06. Student
|
package com.obtk_06; /* * 学生类 * * 起名字我们要求做到见名知意。 * 而我们现在的代码中的n和a就没有做到见名知意，所以我要改进。 * * 如果有局部变量名和成员变量名相同，在局部使用的时候，采用的是就近的原则。 * * 我们有没有办法把局部变量的name赋值给成员变量的name呢? * 有。 * * 什么办法呢? * 用this关键字就可以解决这个问题 * * this:代表所在类的对象引用 * 方法被哪个对象调用，this就代表那个对象 * * 使用场景： * 局部变量隐藏成员变量 */ public class Student { private String name; private int age;
public void setName(String name) { //"林青霞" //name = name; this.name = name; }
public String getName() { return name; }
public void setAge(int age) { //age = age; this.age = age; }
public int getAge() { return age; } } |
com.obtk_06. StudentDemo
|
package com.obtk_06; /* * 学生类的测试类 */ public class StudentDemo { public static void main(String[] args) { //创建对象 Student s = new Student(); System.out.println(s.getName()+"---"+s.getAge());
s.setName("林青霞"); s.setAge(28); System.out.println(s.getName()+"---"+s.getAge()); } } |
构造方法
- 构造方法作用概述
– 给对象的数据进行初始化
- 构造方法格式
– 方法名与类名相同
– 没有返回值类型，连void都没有
– 没有具体的返回值
- 构造方法注意事项
– 如果你不提供构造方法，系统会给出默认构造方法
– 如果你提供了构造方法，系统将不再提供
– 构造方法也是可以重载的
方法重载：
必须在同一个类里
方法名相同
参数列表（方法参数的个数或参数类型）不同
与方法返回值 和方法修饰符没有任何关系
创建类：com.obtk_08. Student
|
测试类：com.obtk_08. StudentDemo
|
package com.obtk_08;
public class StudentDemo { public static void main(String[] args) { //如何调用构造方法呢? //通过new关键字调用 //格式：类名 对象名 = new 构造方法(...); Student s = new Student(); s.show();
//public Student(String name) Student s2 = new Student("林青霞"); s2.show();
//public Student(int age) Student s3 = new Student(28); s3.show();
//public Student(String name,int age) Student s4 = new Student("林青霞",28); s4.show(); } } |
标准类的代码写法和测试
- 类
– 成员变量
– 构造方法
- 无参构造方法
- 带参构造方法
– 成员方法
- getXxx()
- setXxx()
– 给成员变量赋值的方式
- 无参构造方法+setXxx()
- 带参构造方法
com.obtk_09.Student
|
package com.obtk_09; /* * 学生类 */ public class Student { //成员变量 private String name; private int age;
//构造方法 public Student() {}
public Student(String name,int age) { this.name = name; this.age = age; }
//成员方法 public void setName(String name) { this.name = name; }
public String getName() { return name; }
public void setAge(int age) { this.age = age; }
public int getAge() { return age; } } |
com.obtk_09.StudentDemo
|
package com.obtk_09; /* * 学生类的测试类 */ public class StudentDemo { public static void main(String[] args) { //无参+setXxx() Student s = new Student(); s.setName("林青霞"); s.setAge(28); System.out.println(s.getName()+"---"+s.getAge());
//带参构造 Student s2 = new Student("林青霞",28); System.out.println(s2.getName()+"---"+s2.getAge()); } } |
类名作为形式参数和返回值
- 类名作为形式参数案例
– 要的其实是该类的对象
- 类名作为返回值案例
– 返回的其实是该类的对象
- 传入或者传出都可以是对象
- //作为形式参数
- public class Student {
- public void study() {
- System.out.println("好好学习,天天向上");
- }
- }
- public class Teacher {
- public void test(Student s) {
- s.study();
- }
- }
- public class Test {
- public static void main(String[] args) {
- Teacher t = new Teacher();
- Student s = new Student();
- t.test(s);
- }
- }
浙公网安备 33010602011771号