01面向过程与面向对象思想对比

面线过程编程: 自己完成所有的步骤.
面向对象编程: 完成任何一项功能,首先要做的事,就是看看有没有已经写好的,然后,拿过来.
//自己不干活,找别人帮忙干活.

02类和对象的关系

类:是一组具有相同属性和行为的事物的统称.
//类就是类别,比如”人类”,”鱼类”,”哺乳类”,”汽车类”
//属性就是类拥有的”名词”,行为就是类拥有的”动词”
对象:实际存在的事物.万物皆对象.
//其实就是存在的个体. “这个人”,”这条鱼”,”那辆汽车”

03类的定义

  1.   public class 类名{
  2.         //成员变量(属性)
  5.     //成员方法(行为)            
  6. }

04对象的创建和使用

//注意: 类本身是无法使用的.所以,所谓的使用类,其实是使用类的对象.
创建对象: 类名 对象名 = new 类名();
使用对象:
对象名.成员变量;
对象名.成员方法(…);

05案例手机类的创建和使用

  1. package com.itheima.test1;
  3. public class TestPhone {
  4.     public static void main(String[] args) {
  5.         // 1. 创建对象
  6.         Phone p = new Phone();
  7.         // 2. 给成员变量进行赋值
  8.         p.brand = "大米";
  9.         p.price = 2999;
  10.         // 3. 打印赋值后的成员变量
  11.         System.out.println(p.brand + "..." + p.price);
  12.         // 4. 调用成员方法
  13.         p.call("阿强");
  14.         p.sendMessage();
  15.     }
  16. }
  1. package com.itheima.test1;
  3. public class Phone {
  4.     // 品牌, 价格
  5.     String brand;
  6.     int price;
  8.     // 打电话, 发短信
  9.     public void call(String name){
  10.         System.out.println("给"+name+"打电话");
  11.     }
  13.     public void sendMessage(){
  14.         System.out.println("群发短信");
  15.     }
  17. }
  1. package com.itheima.object1;
  3. public class Student {
  4.     // 属性 : 姓名, 年龄
  5.     // 成员变量: 跟之前定义变量的格式一样, 只不过位置发生了改变, 类中方法外
  6.     String name;
  7.     int age;
  9.     // 行为 : 学习
  10.     // 成员方法: 跟之前定义方法的格式一样, 只不过去掉了static关键字.
  11.     public void study(){
  12.         System.out.println("学习");
  13.     }
  15. }
  1. package com.itheima.object1;
  3. public class TestStudent {
  4.     /*
  5.         创建对象的格式:
  6.                 类名 对象名 = new 类名();
  7.         调用成员变量的格式:
  8.                 对象名.变量名
  9.         调用成员方法的格式:
  10.                 对象名.方法名();
  11.      */
  12.     public static void main(String[] args) {
  13.         // 类名 对象名 = new 类名();
  14.         Student stu = new Student();
  15.         // 对象名.变量名
  16.         // 默认初始化值
  17.         System.out.println(stu.name);  // null
  18.         System.out.println(stu.age);   // 0
  20.         stu.name = "张三";
  21.         stu.age = 23;
  23.         System.out.println(stu.name);  // 张三
  24.         System.out.println(stu.age);   // 23
  26.         // 对象名.方法名();
  27.         stu.study();
  28.         // com.itheima.object1.Student@b4c966a
  29.         // 全类名(包名 + 类名)
  30.         System.out.println(stu);
  31.     }
  33. }

06单个对象内存图

07两个对象内存图

08两个引用指向同一个对象内存图

09成员变量和局部变量的区别

10 private关键字

  1. package com.itheima.object2;
  3. /*
  4.     学生类
  6.     private : 私有的
  8.     private是一个权限修饰符
  9.     可以用来修饰成员(变量,方法)
  11.     特点: 只能在本类当中进行访问
  13.  */
  14. public class Student {
  15.     String name;
  16.     private int age;
  18.     // 设置值
  19.     public void setAge(int a){
  20.         if(a >= 0 && a <= 120){
  21.             age = a;
  22.         }else{
  23.             System.out.println("您的年龄不合理");
  24.         }
  25.     }
  27.     // 获取值
  28.     public int getAge(){
  29.         return age;
  30.     }
  32.     public void show(){
  33.         System.out.println(name + "..." + age);
  34.     }
  36. }
  1. package com.itheima.object2;
  3. /*
  4.     学生测试类
  5.  */
  6. public class TestStudent {
  7.     public static void main(String[] args) {
  8.         Student stu = new Student();
  9.         stu.name = "张三";
  10.         //stu.age = 23;
  11.         stu.setAge(-23);
  12.         stu.show();
  13.     }
  14. }

11 private关键字的使用

12this关键字

  1. package com.itheima.mthis;
  3. public class Student {
  4.     private String name;
  6.     public void setName(String name){
  7.         System.out.println("[方法中打印this]");
  8.         System.out.println(this);
  9.         this.name = name;
  10.     }
  12. }

  1. package com.itheima.mthis;
  3. public class TestStudent {
  4.     public static void main(String[] args) {
  5.         Student s1 = new Student();
  6.         System.out.println("[打印对象名]-->  s1");
  7.         System.out.println(s1);
  8.         s1.setName("张三");
  10.         System.out.println("----------------------");
  12.         Student s2 = new Student();
  13.         System.out.println("[打印对象名]-->  s2");
  14.         System.out.println(s2);
  15.         s2.setName("李四");
  16.     }
  18. }

13this内存原理

14封装

  1. package com.itheima.test2;
  3. public class Student {
  4.     private String name;
  5.     private int age;
  7.     public void setName(String name){
  8.         this.name = name;
  9.     }
  11.     public String getName(){
  12.         return name;
  13.     }
  15.     public void setAge(int age){
  16.         this.age = age;
  17.     }
  19.     public int getAge(){
  20.         return age;
  21.     }
  23.     public void show(){
  24.         System.out.println(name + "..." + age);
  25.     }
  27. }
  1. package com.itheima.test2;
  3. public class TestStudent {
  4.     public static void main(String[] args) {
  5.         Student stu = new Student();
  6.         stu.setName("张三");
  7.         stu.setAge(23);
  9.         System.out.println(stu.getName());
  10.         System.out.println(stu.getAge());
  12.         int age = stu.getAge();
  14.         for(int i = 1; i <= age; i++){
  15.             System.out.println("生日快乐");
  16.         }
  18.         stu.show();  // 仅仅是对数据做展示
  19.     }
  21. }
  1. package com.itheima.test2;
  3. public class Test2Student {
  4.     public static void main(String[] args) {
  5.         Student s1 = new Student();
  6.         s1.setName("张三");
  7.         s1.setAge(23);
  9.         s1.show();
  10.     }
  12. }

15构造方法的格式和执行时机

创建对象时执行

  1. package com.itheima.constructor;
  3. public class Student {
  4.     /*
  5.         格式:
  7.                1. 方法名需要跟类名相同, 大小写也要一致
  8.                2. 没有返回值类型, 连void都没有
  9.                3. 没有具体的返回值(不能由return带回具体的结果)
  10.      */
  12.     private String name;
  13.     private int age;
  15.     // 1. 如果一个类中没有编写任何构造方法, 系统将会提供一个默认的无参数构造方法
  16.     public Student(){}
  18.     // 2. 如果手动编写了构造方法, 系统就不会再提供默认的无参数构造方法了
  19.     public Student(String name, int age){
  20.         this.name = name;
  21.         this.age = age;
  22.         System.out.println("我是Student类的构造方法");
  23.     }
  25.     public void show(){
  26.         System.out.println(name + "..." + age);
  27.     }
  29. }

  1. package com.itheima.constructor;
  3. public class TestStudent {
  4.     public static void main(String[] args) {
  5.         Student stu1 = new Student("张三",23);
  6.         stu1.show();
  8.         Student stu2 = new Student();
  9.     }
  11. }

16构造方法的作用

17构造方法的注意事项

18标准类的代码编写与使用

  1. package com.itheima.test3;
  3. /*
  4.     JavaBean类: 封装数据
  5.  */
  6. public class Student {
  7.     private String name;
  8.     private int age;
  10.     public Student() {
  11.     }
  13.     public Student(String name, int age) {
  14.         this.name = name;
  15.         this.age = age;
  16.     }
  18.     public String getName() {
  19.         return name;
  20.     }
  22.     public void setName(String name) {
  23.         this.name = name;
  24.     }
  26.     public int getAge() {
  27.         return age;
  28.     }
  30.     public void setAge(int age) {
  31.         this.age = age;
  32.     }
  34.     public void show(){
  35.         System.out.println(name + "..." + age);
  36.     }
  38. }
  1. package com.itheima.test3;
  3. public class TestStudent {
  4.     public static void main(String[] args) {
  5.         // 1. 无参数构造方法创建对象, 通过setXxx方法给成员变量进行赋值
  6.         Student stu1 = new Student();
  7.         stu1.setName("张三");
  8.         stu1.setAge(23);
  9.         stu1.show();
  11.         // 2. 通过带参数构造方法, 直接给属性进行赋值
  12.         Student stu2 = new Student("李四",24);
  13.         stu2.show();
  14.     }
  16. }