200-Java语言基础-Java编程入门-007 | Java面向对象（一）- 类与对象概述

一、面向对象思想概述
面向对象思想特点：
  • 是一种更符合我们思想习惯的思想
  • 可以将复杂的事情简化
  • 将我们从执行者变成了指挥者
    • 角色发生了转换
面向对象开发：
  • 就是不断的创建对象、使用对象、指挥对象做事情
面向对象设计：
  • 其实就是在管理和维护对象之间的关系
面向对象的特征：
  • 封装（encapsulation）
  • 继承（inheritance）
  • 多态（polymorphism）
二、类与对象概述
我们学习编程是为了什么：
  • 为了把我们日常生活中实物用学习语言描述出来
我们如何描述现实世界事物：
  • 属性：就是该事物的描述信息(事物身上的名词)
  • 行为： 就是该事物能够做什么(事物身上的动词)
Java中最基本的单位是类,Java中用class描述事物也是如此：
  • 成员变量：就是事物的属性
  • 成员方法：就是事物的行为
定义类其实就是定义类的成员(成员变量和成员方法)：
  • 成员变量：和以前定义变量是一样的，只不过位置发生了改变。在类中，方法外。
  • 成员方法：和以前定义方法是一样的，只不过把static去掉，后面在详细讲解static的作用。
类和对象的概念：
  • 类：是一组相关的属性和行为的集合
  • 对象：是该类事物的具体体现
  • 举例：
    • 类     学生
    • 对象    具体的某个学生就是一个对象
1、学生类的定义
 1 class JavaDemo {
 2   public static void main(String[] args) {
 3     
 4   }
 5 }
 6 /*
 7    * A:案例演示
 8      * 属性:姓名,年龄,性别
 9      * 行为:学习,睡觉
10    * B:我们如何描述现实世界事物
11      * 属性  就是该事物的描述信息(事物身上的名词)
12      * 行为  就是该事物能够做什么(事物身上的动词)
13    * C:Java中最基本的单位是类,Java中用class描述事物也是如此
14      * 成员变量  就是事物的属性
15      * 成员方法  就是事物的行为
16    * D:定义类其实就是定义类的成员(成员变量和成员方法)
17      * a:成员变量  和以前定义变量是一样的，只不过位置发生了改变。在类中，方法外。
18      * b:成员方法  和以前定义方法是一样的，只不过把static去掉，后面在详细讲解static的作用。
19    */
20 class Student {
21   String name;          // 姓名
22   int age;              // 年龄
23   String gender;        // 性别
24   
25   public void study() { // 定义学习的方法
26     System.out.println("学生学习");
27   }
28   
29   public void sleep() { // 定义睡觉的方法
30     System.out.println("学生睡觉");
31   }
32 }
1.1、学生类的使用
 1 /*
 2 * A:文件名问题
 3    * 在一个java文件中写两个类：一个基本的类，一个测试类。
 4    * 建议：文件名称和测试类名称一致。
 5 * B:如何使用对象?
 6    * 创建对象并使用
 7    * 格式：类名 对象名 = new 类名();
 8 * D:如何使用成员变量呢?
 9    * 对象名.变量名
10 * E:如何使用成员方法呢?
11    * 对象名.方法名(...)
12 */
13 class JavaDemo {
14   public static void main(String[] args) {
15     // 创建对象并使用 格式：类名 对象名 = new 类名();
16     // 对象名：其实就是合法的标识符，如果一个单词所有字母小写；如果多个单词，从第二个单词开始首字母大写
17     Student student = new Student();
18     // 如何使用成员变量呢?
19     // 对象名.变量名
20     student.name = "张三";
21     student.age = 18;
22     student.gender = "男";
23     System.out.println(student.name + "..." + student.age + "..." +  student.gender);
24     // 如何使用成员方法呢?
25     // 对象名.方法名(...)
26     student.study();
27     student.sleep();
28   }
29 }
30 /*
31 * A:案例演示
32    * 属性:姓名,年龄,性别
33    * 行为:学习,睡觉
34 * B:我们如何描述现实世界事物
35    * 属性  就是该事物的描述信息(事物身上的名词)
36    * 行为  就是该事物能够做什么(事物身上的动词)
37 * C:Java中最基本的单位是类,Java中用class描述事物也是如此
38    * 成员变量  就是事物的属性
39    * 成员方法  就是事物的行为
40 * D:定义类其实就是定义类的成员(成员变量和成员方法)
41    * a:成员变量  和以前定义变量是一样的，只不过位置发生了改变。在类中，方法外。
42    * b:成员方法  和以前定义方法是一样的，只不过把static去掉，后面在详细讲解static的作用。
43 */
44 class Student {
45   String name;          // 姓名
46   int age;              // 年龄
47   String gender;        // 性别
48   
49   public void study() { // 定义学习的方法
50     System.out.println("学生学习");
51   }
52   
53   public void sleep() { // 定义睡觉的方法
54     System.out.println("学生睡觉");
55   }
56 }
2、手机类的定义
 1 class JavaDemo {
 2   public static void main(String[] args) {
 3     System.out.println("Hello World");
 4   }
 5 }
 6 /*
 7 * 模仿学生类，让学生自己完成
 8    * 属性:品牌(brand)价格(price)
 9    * 行为:打电话(call),发信息(sendMessage)玩游戏(playGame)
10 */
11 class Phone {
12   String brand;          // 品牌
13   int price;             // 价格
14   
15   // 定义打电话的方法
16   public void call() {
17     System.out.println("打电话");
18   }
19   
20   // 定义发信息的方法
21   public void sendMessage() {
22     System.out.println("发信息");
23   }
24   
25   // 定义玩游戏的方法
26   public void playGame() {
27     System.out.println("玩游戏");
28   }
29 }
30  
31 2.1、手机类的使用
32 class JavaDemo {
33   public static void main(String[] args) {
34     // 创建对象
35     Phone p = new Phone();
36     // 调用成员变量
37     p.brand = "iphone";
38     p.price = 8888;
39     System.out.println(p.brand + "..." + p.price);
40     // 调用成员方法
41     p.call();
42     p.sendMessage();
43     p.playGame();
44         
45   }
46 }
47 /*
48 * 手机类
49    * 属性:品牌(brand)价格(price)
50    * 行为:打电话(call),发信息(sendMessage)玩游戏(playGame)
51 */
52 class Phone {
53   String brand;          // 品牌
54   int price;             // 价格
55   
56   // 定义打电话的方法
57   public void call() {
58     System.out.println("打电话");
59   }
60   
61   // 定义发信息的方法
62   public void sendMessage() {
63     System.out.println("发信息");
64   }
65   
66   // 定义玩游戏的方法
67   public void playGame() {
68     System.out.println("玩游戏");
69   }
70 }
 
三、对象的内存图
1、一个对象的内存图
 1 class JavaDemo {
 2   public static void main(String[] args) {
 3     Car c1 = new Car();
 4     
 5     // 调用成员变量并赋值
 6     c1.color = "red";
 7     c1.num = 4;
 8     
 9     // 调用成员方法
10     c1.run();
11   }
12 }
13 /*
14 * 车类
15    * 属性:颜色、轮胎数
16    * 行为:车运行
17 */
18 class Car {
19   String color;          // 颜色
20   int num;               // 轮胎数
21   
22   // 定义车运行的方法
23   public void run() {
24     System.out.println(color + "..." + num);
25   }
26 }
2、二个对象的内存图
 1 class JavaDemo {
 2   public static void main(String[] args) {
 3     Car c1 = new Car();
 4     
 5     // 调用成员变量并赋值
 6     c1.color = "red";
 7     c1.num = 4;
 8     
 9     // 调用成员方法
10     c1.run();
11     
12     Car c2 = new Car();
13     
14     // 调用成员变量并赋值
15     c2.color = "black";
16     c2.num = 8;
17     
18     // 调用成员方法
19     c2.run();
20     
21     // 用null把原来的地址值覆盖掉了
22     c2 = null;
23     // c2里面记录的是null，所以报出了空指针异常
24     c2.run();
25   }
26 }
27 /*
28 * 车类
29    * 属性:颜色、轮胎数
30    * 行为:车运行
31 */
32 class Car {
33   String color;          // 颜色
34   int num;               // 轮胎数
35   
36   // 定义车运行的方法 
37   public void run() {
38     System.out.println(color + "..." + num);
39   }
40 }
3、三个引用两个对象的内存图
 1 class JavaDemo {
 2   public static void main(String[] args) {
 3     Car c1 = new Car();
 4     
 5     // 调用成员变量并赋值
 6     c1.color = "red";
 7     c1.num = 4;
 8     
 9     // 调用成员方法
10     c1.run();
11     
12     Car c2 = new Car();
13     
14     // 调用成员变量并赋值
15     c2.color = "black";
16     c2.num = 8;
17     
18     // 调用成员方法
19     c2.run();
20     
21     Car c3 = c2;
22     c3.run();
23   }
24 }
25 /*
26 * 车类
27    * 属性:颜色、轮胎数
28    * 行为:车运行
29 */
30 class Car {
31   String color;          // 颜色
32   int num;               // 轮胎数
33   
34   // 定义车运行的方法
35   public void run() {
36     System.out.println(color + "..." + num);
37   }
38 }
 
三、成员变量和局部变量的区别
在类中的位置不同：
  • 成员变量：在类中方法外
  • 局部变量：在方法定义中或者方法声明上
在内存中的位置不同：
  • 成员变量：在堆内存(成员变量属于对象,对象进堆内存)
  • 局部变量：在栈内存(局部变量属于方法,方法进栈内存)
生命周期不同：
  • 成员变量：随着对象的创建而存在，随着对象的消失而消失
  • 局部变量：随着方法的调用而存在，随着方法的调用完毕而消失
初始化值不同：
  • 成员变量：有默认初始化值
  • 局部变量：没有默认初始化值，必须定义，赋值，然后才能使用。
注意事项：
  • 部变量名称可以和成员变量名称一样，在方法中使用的时候，采用的是就近原则。
  • 基本数据类型变量包括哪些:byte,short,int,long,float,double,boolean,char
  • 引用数据类型变量包括哪些:数组,类,接口,枚举
 1 class JavaDemo {
 2   public static void main(String[] args) {
 3     Person p = new Person();
 4     p.speak(10);
 5   }
 6 }
 7 /*
 8 * A:在类中的位置不同
 9    * 成员变量：在类中方法外
10    * 局部变量：在方法定义中或者方法声明上
11 * B:在内存中的位置不同
12    * 成员变量：在堆内存(成员变量属于对象,对象进堆内存)
13    * 局部变量：在栈内存(局部变量属于方法,方法进栈内存)
14 * C:生命周期不同
15    * 成员变量：随着对象的创建而存在，随着对象的消失而消失
16    * 局部变量：随着方法的调用而存在，随着方法的调用完毕而消失
17 * D:初始化值不同
18    * 成员变量：有默认初始化值
19    * 局部变量：没有默认初始化值，必须定义，赋值，然后才能使用。
20    
21 * 注意事项：
22    * 局部变量名称可以和成员变量名称一样，在方法中使用的时候，采用的是就近原则。
23    * 基本数据类型变量包括哪些:byte,short,int,long,float,double,boolean,char
24    * 引用数据类型变量包括哪些:数组,类,接口,枚举
25 */
26 class Person {
27   // 成员变量
28   String name;
29   int num;
30   public void speak(int x) {
31     // x和num都是局部变量
32     int num = 10;
33     System.out.println(name);
34     System.out.println(num);
35   }
36 }
 
四、方法的形式参数是类名的时候如何调用
 1 class JavaDemo {
 2   public static void main(String[] args) {
 3     print(10);
 4     // 创建对象，并将对象的地址赋值给s
 5     Student s = new Student();
 6     print(s);
 7   }
 8   
 9   // 基本数据类型当作形式参数
10   public static void print(int x) {
11     System.out.println(x);
12   }
13   
14   //引用数据类型当作形式参数
15    public static void print(Student stu) {
16      stu.name = "张三";
17      stu.age = 23;
18      stu.speak();
19    }
20 }
21 /*
22 * A:方法的参数是类名public void print(Student s){}//print(new  Student());
23    * 如果你看到了一个方法的形式参数是一个类类型(引用类型)，这里其实需要的是该类的对象。
24 */
25 class Student {
26   // 成员变量
27   String name;
28   int age;
29   public void speak() {
30     System.out.println(name + "..." + age);
31   }
32 }
 
五、匿名对象的概述和应用
什么是匿名对象：
  • 没有名字的对象
匿名对象应用场景：
  • 调用方法，仅仅只调用一次的时候。
    • 那么，这种匿名调用有什么好处吗?
      • 节省代码
    • 注意：调用多次的时候，不适合。匿名对象调用完毕就是垃圾。可以被垃圾回收器回收。
  • 匿名对象可以作为实际参数传递
 1 /*
 2 * A:什么是匿名对象
 3    * 没有名字的对象
 4 * B:匿名对象应用场景
 5    * a:调用方法，仅仅只调用一次的时候。
 6      * 那么，这种匿名调用有什么好处吗?
 7        * 节省代码
 8      * 注意：调用多次的时候，不适合。匿名对象调用完毕就是垃圾。可以被垃圾回收器回收。
 9    * b:匿名对象可以作为实际参数传递
10 * C:案例演示
11    * 匿名对象应用场景
12 */
13 class JavaDemo {
14   public static void main(String[] args) {
15     /*
16     // 创建有名字的对象
17    Car c1 = new Car();
18    c1.run();
19    
20    // 匿名对象调用方法
21    new Car().run();
22    // 匿名对象只适合对方法的一次调用，因为调用多次就会产生多个对象，不如用有名的对象
23    new Car().run();
24    */
25     
26     // 匿名对象是否可以调用属性并赋值？有什么意义
27     /*
28      * 匿名对象可以调用属性，但是没有意义，因为调用后就变成垃圾
29      * 如果需要赋值还是使用有名字的对象
30      */
31     new Car().clor = "red";
32     new Car().num = 4;
33     new Car().run();   // null...0运行
34   }
35 }
36 class Car {
37   // 成员变量
38   String clor;
39   int num;
40   public void run() {
41     System.out.println(clor + "..." + num + "运行");
42   }
43 }
44 /*
45 * A:什么是匿名对象
46    * 没有名字的对象
47 * B:匿名对象应用场景
48    * a:调用方法，仅仅只调用一次的时候。
49      * 那么，这种匿名调用有什么好处吗?
50        * 节省代码
51      * 注意：调用多次的时候，不适合。匿名对象调用完毕就是垃圾。可以被垃圾回收器回收。
52    * b:匿名对象可以作为实际参数传递
53 * C:案例演示
54    * 匿名对象应用场景
55 */
56 class JavaDemo {
57   public static void main(String[] args) {
58     // 创建有名字的对象
59     // Car c1 = new Car();
60     // method(c1);
61     method(new Car());
62     // Car c2 = new Car();
63     // method(c2);
64     method(new Car());             // 匿名对象可以当做参数传递
65   }
66   // 抽取方法提高代码的复用性
67   public static void method (Car cc) {
68     cc.clor = "red";
69     cc.num = 4;
70     cc.run();
71   }
72 }
73 class Car {
74   // 成员变量
75   String clor;
76   int num;
77   public void run() {
78     System.out.println(clor + "..." + num + "运行");
79   }
80 }
五、封装的概述
封装概述：
  • 是指隐藏对象的属性和实现细节，仅对外提供公共访问方式。
封装好处：
  • 隐藏实现细节，提供公共的访问方式
  • 提高了代码的复用性
  • 提高安全性。
封装原则：
  • 将不需要对外提供的内容都隐藏起来。
  • 把属性隐藏，提供公共方法对其访问。
 
1、private关键字的概述和特点
private关键字特点：
  • 是一个权限修饰符
  • 可以修饰成员变量和成员方法
  • 被其修饰的成员只能在本类中被访问
 1 /*
 2 * :人类赋值年龄的问题
 3 * B:private关键字特点
 4    * a:是一个权限修饰符
 5    * b:可以修饰成员变量和成员方法
 6    * c:被其修饰的成员只能在本类中被访问
 7 * C:案例演示
 8    * 封装和private的应用：
 9    * A:把成员变量用private修饰
10    * B:提供对应的getXxx()和setXxx()方法
11    * private仅仅是封装的一种体现形式,不能说封装就是私有
12 */
13 class JavaDemo {
14   public static void main(String[] args) {
15     Person p1 = new Person();
16     p1.name = "张三";
17     // p1.age = -23;
18     // p1.speak();
19     p1.setAge(23);
20     System.out.println(p1.getAge());
21   }
22 }
23 class Person {
24   // 成员变量
25   String name;
26   private int age;
27   
28   // 获取年龄
29   public int getAge() {
30     return age;
31   }
32   // 设置年龄
33   public void setAge(int age) {
34     if (age > 0 && age < 200) {
35       age = age;
36     } else {
37       System.out.println("哈哈哈");
38     }
39     
40   }
41   public void speak() {
42     System.out.println(name + "..." + age);
43   }
44 }
2、this关键字的概述和应用
this关键字特点：
  • 代表当前对象的引用
 1 /*
 2 * A:this关键字特点
 3    * 代表当前对象的引用
 4 * B:案例演示
 5    * this的应用场景
 6    * 用来区分成员变量和局部变量重名
 7 */
 8 class JavaDemo {
 9   public static void main(String[] args) {
10     Person p1 = new Person();
11     p1.setName("张三");
12     p1.setAge(23);
13     System.out.println(p1.getName() + "..." + p1.getAge());
14     
15     Person p2 = new Person();
16     p2.setName("李四");
17     p2.setAge(18);
18     System.out.println(p2.getName() + "..." + p2.getAge());
19   }
20 }
21 class Person {
22   // 成员变量
23   private String name;
24   private int age;
25   
26   // 获取年龄
27   public int getAge() {
28     return age;
29   }
30   // 设置年龄
31   public void setAge(int age) {
32     if (age > 0 && age < 200) {
33       this.age = age;
34       // System.out.println(age);
35     } else {
36       System.out.println("哈哈哈");
37     }
38     
39   }
40   //获取姓名
41   public String getName() {
42     return name;
43   }
44   //设置姓名
45   public void setName(String name) {
46     this.name = name;
47     // System.out.println(name);
48   }
49   public void speak() {
50     System.out.println(name + "..." + age);
51   }
52 }
 
 
 
 
 
 
 
 
 
 
 
 
posted @ 2021-03-15 10:05  sftp  阅读(106)  评论(0)  编辑  收藏  举报