Java day22

集成开发环境

             1.  集成开发环境简称 IDE
                  什么是集成开发环境？
                      * 集成开发环境可以让代码变得更加简单，更加高效
                      * 没有IDE 工具：
                                - 需要安装JDK，需要配置环境变量、需要手动的将Java源文件生成字节码文件
                                
          2.   实例变量不能直接采用类名的形式直接访问
          3.   对于程序来说，类中的属性可以随意访问，这样导致属性的数据不安全
          4.   面向对象的特征：
                      - 封装
                               * 封装的好处？
                                        —— 封装之后，对于事 物来说，看不到这个事物的复杂的一面，只看到简单的一面
                                                 复杂性封装对外提供简单的一面
                               * 为什么要封装？
                                       —— 封装之后才会形成真正的“对象”，真正的独立体
                                                封装之后提高了事物的安全性，适应性
                               * 封装的步骤
                                         - 所有属性私有化，使用private进行修饰，private表示私有的
                                           所有的数据只能在本类中进行访问
                                           进行封装之后再终端输出的时候是会报错的，不能访问了
                                           私有属性不能在  外部直接访问
                                         - 对外提供简单的操作入口
                                           也就是说以后外部程序要想访问属性，必须通过这些简单的入口进行访问
                                            对外提供公开的set和get方法
                                            修改属性调用set（修改）
                                            读取属性调用get（读取）
                                            这两种方法的命名规范：
                                                    public void set +属性名 首字母大写（形参）  {   
                                                    } 
                                                     
                                                    public 返回值类型 get属性名 首字母大写（）{
                                                      return 属性名；
                                                      这里的return一样的用法
                                                      是void的就不用return
                                                    }
                                                     
                                                   public void set 属性名首字母大写（形参）{
                                                   }
                                                   public 返回值类型  get属性名 首字母大写（）{
                                                   return 属性名；
                                                   }
                                                   注意：
                                                           他们都没有static静态变量，所以调用是直接
                                                           引用.属性名（）；
                                  
                                
                                一个属性访问的几种形式：
                                       * 想读取这个属性值，读取get
                                       * 想修改这个属性值，修改set
                                get和set没有static关键字，怎么调用？
                                      * 有static关键字的调用格式：类名.方法名（实参）；
                                      * 没有static关键字的调用格式：引用.属性名（实参）；
                                
                      - 继承
                               * 继承的作用是：代码复用
                               * 继承最重要的作用是：有了继承，才有后面的方法覆盖和多态
                               * 继承的语法格式：
                                         【修饰符列表】class 类名 extends 父类名{
                                         属性
                                         方法
                                         } 
                               * Java语言中继承只支持单继承，一个类不能同时继承很多类，只能继承一个类
                               * 但是一个类也能间接继承其他类
                               　如：C　ｅｘｔｅｎｄｓB｛
                               　｝
                               　　Ｂ　ｅｘｔｅｎｄｓ　Ａ｛
                               　｝
                               　Ａ　ｅｘｔｅｎｄｓ T｛
                               　｝
                               　　c类直接继承b类，但是c类间接继承a、t
                               * Java语言中假设一个类没有显示继承任何类，该类默认继承javase库中提供的Java.lang.object    
                               * c++中，支持继承多个类
                               * 继承的一些术语：
                                          B类继承A类：
                                         Ａ类称为：父类、基类、超类（ｓｕｐｅｒｃｌａｓｓ）
                                         Ｂ类称为：字类。派生类（ｓｕｂｃｌａｓｓ）
                              ＊ 字类继承父类的哪些数据呢？
                              　　　－私有的不支持继承
                              　　　－构造方法不支持继承
                              　　　－其他支持继承         	  
                      - 多态
                              1. 关于多态中涉及到的几个概念：（类型转换）
                                      - 向上转型（upcasting）：子类型向父类型转换（自动类型转换）
                                                                                 一旦，转型为父类型就无法调用子类型的方法
                                                                                 如：猫转型为动物【这里是猫直接变成了父类型】
                                      - 向下转型（downcasting）：父类型向字类型转换（强制类型转换【强制类型转换符】）
                                      - 无论是向上转型还是向下转型，两种类型之间必须要有继承关系
                                        没有继承关系，编译无法通过
                                        如：
                                              animal a2 = new cat（）；
                                              （向上转型）  animal是父类，cat是字类 	
                                               父类型引用指向子类型，
                                                 父类型引用指向子类型对象，这种机制导致程序存在编译阶段绑定和运行阶段绑定两种
                                                 不同的形态/状态
                                      - 若要执行多种形态的方法，怎样执行？
                                               * 进行强制类型转换 向下类型转换
                                               * 什么时候需要使用向下类型转换？
                                                         当调用的方法   或者  访问的属性是子类中特有的方法
                                                         在父类中不存在，必须执行向下转型   
                                      - 类型转换异常
                                               * Java.lang.class对象名exception 
                                               * 这种异常总会在向下转型的时候 会出现报错（运行阶段） 
                                               * 原因是：对象之间没有继承关系	
                                               * 怎么避免报错？
                                                        使用   instanceof 运算符可以避免出现异常
                                                        
                                               * instance of 的使用
                                                       _ 语法格式：
                                                                        （引用  instance of 数据类型名）
                                                                       翻译为：......的实例方法
                                                       _ 以上运算符执行结果类型是：布尔类型，结果可能是 true/false
                                                       _ 关于运算结果
                                                       比如：（a instanc of Animal）
                                                                true表示：a这个引用执行对象是一个Animal类型
                                                                false表示：a这个引用执行对象不是一个Animal类型                          
                                                        
                                               * 注意：
                                                         _ 向下转型只要编译通过，一定不会出问题
                                                         _ 在向下类型转换过程中尽量使用instanceof
                                                                                   
                              2. 多态在实际开发中的作用
                                       - 对象与对象之间协作起来就会系形成系统
                                       - 类面向是一个抽象的类，不在是具体的类
                                       - 要培养面向抽象编程
                                       - 降低程序的耦合度，提高程序的扩展力     
                              3. 写代码应该开始向抽象的方面进行转变，这才是Java发展的方向，例题：多态的第三讲课      

构造函数

         1.    构造方法又被称为构造器/构造函数
        2.     构造函数的语法结构
                     【修饰符列表】 构造方法名 （形式参数列表）{
                       构造方法体；
                     }
             普通方法的语法结构：
                      【修饰符列表】返回值类型 方法名（形式参数列表）{
                      方法体；
                      return 字面值；
                      }
             注意：
                   *  对于构造方法来说返回值类型不需要指定，不用写 
                   * 构造方法的方法名必须和类名保持一致性
             
           3.  构造方法的作用
                    构造函数是对象一建立就运行，给对象初始化，就包括属性，执行方法中的语句。

而一般函数是对象调用才执行，用 “.方法名” 的方式，给对象添加功能。

一个对象建立，构造函数只运行一次。

而一般函数可以被该对象调用多次
通过构造方法的调用，可以创建对象
创建对象的同时，初始化实例变量的内存空间【给实例变量赋值】
怎么调用
构造方法的调用：
这是创建对象
new 构造方法名（实参列表）；
如：new student（）；

                            引用.方法名（）；
                            如：s.name（）；
                            （修饰符中没有static的时候）
                           
                     普通方法的调用：
                            类名.方法名（实参）；
                            如：idea02.sumInt("20,30");
                            （修饰符中有static的时候）

                 4.    构造方法执行结束之后，是有返回值的
                     如：user u = new user（）；（隐含无参数构造方法）
                     这里的构造方法的返回给了 u，即 在类的类型
                     
                  5. 快捷键：
                                 ctrl+/  //注释
                                 ctrl+shift+/  // 多行注释
                                 ctrl+o   查看（在当前类中）
                                 ctrl+ 查看调用的方法
                                 快编辑 ，支持多行编辑
                                 
                                 
                  6. 当一个类中没有定义构造方法的时候
                      系统默认给该类提供一个无参数的构造方法，这个构造方法被称为  缺省构造器
                      当一个类显示的构造方法定义后，那么系统将不在默认的给该类提供无参数的构造方法
                      开发中应当手动的提供无参数构造方法
                      
                   7. 构造方法支持重载机制，在一个类中编写多个构造方法，这写构造方法已经构成了重载机制

参数传递

              1. 空引用：只用一个空的引用，访问实例变量相关的数据会出现空指针异常
              2. 方法调用的时候，参数是怎么传递的
                         2.1 传递的时候，Java只遵循一种机制，就是将变量中保存的  值  进行传递
                               这个值可以是字面值。也可以是Java对象的内存地址