第六讲

Java基础知识第六讲

一.面向对象思想概述

  • 什么是面向对象?
    • 面向对象指的是一种编程思想,是将一些飘忽不定的思想方法落实到对应的对象上,面向过程强调的是过程,面向对象着重于对象,面向对象基于面向过程.
  • 面向对象思想特点
    • 是一种更符合我们思想习惯的思想(懒人思想)
    • 可以将复杂的事情简单化
    • 将我们从执行者变成了指挥者(角色发生了转换)
  • :面向对象开发
    • 就是不断的创建对象,使用对象,指挥对象做事情。
  • 面向对象设计
    • 就是在管理和维护对象之间的关系。
  • 面向对象特征
    • 封装(encapsulation)
    • 继承(inheritance)
    • 多态(polymorphism)
      ###二.类与对象概述
  • 学习编程的目的
    • 为了把我们日常生活中实物用学习语言描述出来
  • 如何描述现实世界事物
    • 属性—-就是该事物的描述信息(事物身上的名词)
    • 行为—-就是该事物能够做什么(事物身上的动词)
  • Java中最基本的单位是类.(Java中用class描述事物也是如此)
    • 成员变量–就是事物的属性
    • 成员方法–就是事物的行为
  • 定义类其实就是定义类的成员(成员变量和成员方法)
    • 成员变量–和以前定义变量是一样的,只不过位置发生了改变,在定义在类中方法之外。
    • 成员方法–和以前定义方法是一样的,只不过把static去掉,后面在详细讲解static的作用。
  • 类和对象的概念
    • 类:是一组相关的属性和行为的集合(例如一个班的学生就是一个类)
    • 对象:是该类事物的具体体现(具体的某个学生就是一个对象)

三.学生类的定义及其使用

  • 学生类
    • 属性:姓名,年龄,性别
    • 行为:学习,睡觉
  • 学生类的使用
    • 文件名问题
      • 在一个java文件中写两个类:一个基本的类,一个测试类。
      • 建议:文件名称和测试类名称一致。
    • 如何使用对象
      • 创建对象并使用
      • 格式:类名 对象名 = new 类名();
  • 如何使用成员变量
    • 对象名.变量名
  • 如何使用成员方法

    • 对象名.方法名(…)

      class Demo_Student {
          public static void main(String[] args) {        //主方法类
      
              //创建对象格式: 类名 对象名 = new 类名 () ;
              //对象名的命名方法:就是一个合适的标识符,如果是一个单词,所有字母小写,如果是多个单词,首字母小写,从第二个字母其首字母大写. 
              student s = new student();
      
              //使用成员变量----对象名.方法名
              s.name = "李四";
              s.age = 20;
              s.gender = "男士";
              System.out.println(s.name + "----" + s.age + "----" + s.gender);
      
              //使用成员方法----对象名.方法名(...)
              s.study();
              s.sleep();
          }
      }
      
      class student {             //测试类
          String name;            //属性:姓名
          int age;                //属性:年龄
          String gender;          //属性:性别
      
          public void study() {
              System.out.println("学生学习");     //定义学习的方法
          }
          public void sleep() {
              System.out.println("学生睡觉");     //定义睡觉的方法
          }
      }
      

四.手机类的定义及其使用

  • 手机类

    • 属性:品牌(brand)价格(price)
    • 行为:能打电话(call),能发信息(sendMessage),能玩游戏(playGames)

       class Demo_Phone {
          public static void main(String[] args) {        //主方法类
              phone p = new phone();                      //创建对象格式
              p.brand = "苹果6S";                           //使用成员变量
              p.price = 4998;
      
              System.out.println(p.brand + "---" + p.price);
      
              p.call();                           //使用成员方法
              p.sendMessage();
              p.playGames();
          }
      } 
      
       class phone {
          String brand;           //品牌
          int price;              //价格
      
          public void call() {
              System.out.println("能打电话");     //定义手机能打电话
          } 
          public void sendMessage() {
              System.out.println("能发信息");     //定义手机能发信息
          }   
          public void playGames() {
              System.out.println("能打游戏");     //定义手机能打游戏
          } 
       }
      

五.成员变量和局部变量的区别

  • 在类中的位置不同
    • 成员变量在类中方法之外
    • 局部变量在方法定义中,或方法声明上;
  • 在内存中位置不同
    • 成员变量在堆内存中(成员变量属于对象,对象进堆内存);
    • 局部变量在栈内存中(局部变量属于方法,方法进栈内存).
  • 生命周期不同
    • 成员变量随着对象的创建而存在,随着对象的消失而消失;
    • 局部变量随着方法的调用而存在,随着方法的调用完毕而消失.
  • 初始化值不同
    • 成员变量有默认的初始化值;
    • 局部变量么有默认的初始化值,必须先定义,赋值后,才能使用.
  • 注意事项:

    • 局部变量名称可以和成员变量名称一样,在方法使用时采用的是就近原则;
    • 基本数据类型变量包括:byte,shoot,long,int,char,double,float,boolean;
    • 引用数据类型变量包括:数组,类,接口,枚举.

      class Demo_person {
          public static void main(String[] args) {
              person p = new person();
              p.speak();
          }
      }
      
      class person {
          String name;            //成员变量
          public void speak() {
          int num = 10;           //局部变量
          System.out.println(name);
          System.out.println(num);
          }
      }
      
  • 方法的形式参数是类名的时候要如何调用

        class Demo2_person {
            public static void main(String[] args) {
                    print(10);
    
                student s = new student();
                    print(s);
            }
    
            public static void print(int x) {           //基本数据类型当做形式参数,给的是值
                System.out.println(x);
            }
    
            public static void print(student s){        //应用数据类型当做形式参数,给的是地址值
                s.name = "张三";
                s.age = 22;
                s.speak();
            }
        }
    
        class student {
            String name;
            int age;
    
            public void speak() {
                System.out.println(name + "----" + age);
            }
        }
    

六.匿名对象的概述及其应用

  • 匿名对象—-指的是没有名字的对象
  • 匿名对象的应用
    • 调用方法,仅仅调用一次的时候(这样调用的好处是可以节省代码)
    • 调用多次的时候不合适,匿名对象调用完就是垃圾,可以被垃圾回收器回收.
    • 匿名对象可以实际参数来传递
  • 匿名对象是否可以调用对象并赋值,有什么意思?

    • 匿名对象可以调用对象,但是没有什么意义,因为调用完之后就会变成垃圾,如果要赋值还是用有名对象好.

       class Demo2_car {
          public static void main(String[] args) {
              //Car c = new Car();            //创建有名字的对象
              //c.run();
      
              //new Car().run();          //匿名对象调用方法
      
              Car c = new Car();
              c.color = "blue";
              c.num = 8;
              c.run();
      
              //用for循环来提高代码的复用性,匿名对象可以当做参数传递
              for (int i = 1;i <= 10 ;i++ ) {
              Car ci = new Car();
              ci.color = "red";
              ci.num = 4;
              ci.run();
              }
          }
      }
      class Car {
          String color;
          int num;
          public void run(){
              System.out.println("车运行" + "---" + color + "---" + num);
          }
      }
      

七.封装的概述

  • 封装的定义
    • 指的是隐藏对象的属性和实现细节,仅对外提供公共访问方式
  • 封装的好处
    • 隐藏实现细节,提供公共访问方式
    • 提高了代码的复用性
    • 提高安全性
  • 封装的原则:
    • 将不需要对外提供的内容隐藏起来;
    • 把属性隐藏,提供公共方式对其访问.

八.private关键字的概述和特点

  • private关键字的特点:
    • 是一个极限修饰符;
    • 可以修饰成员变量和成员方法;
    • 被其修饰的成员只能在本类中被访问.
  • 封装和private的应用:

    • 把成员变量用private修饰;
    • 提供对应的 getXxx() 和 setXxx() 方法;
    • private仅仅是封装的一种体现形式,不能说封装就是private.

      class Demo5_Person {
          public static void main(String[] args) {
          Person p = new Person();        //创建对象
          p.name = "rose";        //调用姓名属性并赋值
           //p.age = 23;              //调用年龄属性并赋值
          //p.age = -16;
          p.speak();              //调用行为属性
          p.setAge(-17);
              System.out.println(p.getAge());
          }
      }
      
      class Person {
              String name;        //姓名
              private int age;            //年龄
      
          public void setAge(int a) {         //设置年龄
              if (a > 0 && a < 150) {
                  age = a;
              }else {
                  System.out.println("唐僧是你爹吧!!!");
              }
          }
      
          public int getAge() {
              return age;
          }
          public void speak(){
              System.out.println("姓名是" + name + ",年龄是" + age);
          } 
      }
      

九.this 关键字的概述和应用

  • 关键字特点: 代表当前对象的引用,即谁调用this,this就代表谁.
  • this 的应用的场景: 用来区分成员变量和局部变量的重名.

    class Demo_This {
        public static void main(String[] args) {
            Person p1 = new Person();       //创建对象
            p1.setName("隔壁老王");
            p1.setAge(23);
            System.out.println(p1.getName() + "..." + p1.getAge());
    
            Person p2 = new Person();
            p2.setName("楼下八万");
            p2.setAge(24);
            System.out.println(p2.getName() + "..." + p2.getAge());
        }
    }
    
    class Person {
        private String name;        //姓名
        private int age;            //年龄
    
        public void setAge(int age) {       //设置年龄
            if (age > 0 && age < 150) {
                this.age = age;             //成员变量和局部变量重名,在成员   变量前加this.
            }else {
            System.out.println("你爸比是唐僧吧");
            }
        }
    
        public int getAge() {       //获取年龄
            return this.age;        //this可以省略,因为当你不加的时候系统会默认给你加.
        }
    
        public void setName(String name) {      //设置姓名
            this.name = name;
        }
        public String getName() {           //获取姓名
            return name;                
        }
    }
    
  • 练习

    • 将手机做成一个标准类,然后创建对象测试功能.

          /*属性: 品牌,价格.
          行为: 打电话(call),发信息(sendMessage),打游戏(playGame)*/
      
      class Test_This {
          public static void main(String[] args) {
              Phone p = new Phone();
              p.setBrand("苹果");
              p.setPrice(4988);
              System.out.println("手机品牌是" + p.getBrand() + "..." + "手机的价格是" + p.getPrice());
              p.call();
              p.sendMessage();
              p.playGame();
          }
      }
      
      class Phone {
          private String brand;       //品牌
          private int price;          //价格
      
          public void setBrand(String brand) {        //设置品牌
              this.brand = brand; 
          }
      
          public String getBrand() {                  //获取品牌
              return brand;                       
          }
      
          public void setPrice(int price) {           //设置价格
              this.price = price;
          }
      
          public int getPrice() {                     //获取价格
              return price;
          }
      
          public void call() {                        //打电话
              System.out.println("该可以打电话");
          }
          public void sendMessage() {                 //发信息
              System.out.println("该可以发信息");
          }
          public void playGame() {                    //打游戏
              System.out.println("该可以打游戏");
          }
      }
      
  • 0
    点赞
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论

“相关推荐”对你有帮助么?

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值