学习Java第三周总结:

静态static关键字的特点:
    1)随着类的加载而加载
    2)优先于对象存在:  它不能this共存   (this:代表当期类对象的地址值引用)
               对象还没有new的时候,当前被static修饰的成员就已经内存了
 
    3)被静态修饰的 可以被多个对象共享:有共享共用的意思
 
    4)被静态修饰的变量,方法----->静态变量或者静态方法
           我们所说的成员变量和成员方法:都指的是非静态
           静态的成员的访问方式:类名.变量
                                类名.方法名()
  关于static关键字的使用注意事项
 
   1)非静态的方法既可以访问静态变量,也可以访问非静态的变量
                既可以调用静态方法,也可以调用非静态方法
 
   2)静态的方法:只能访问静态变量,
               只能调用静态方法
               简单记:静态只能访问静态

冒泡排序的思想以及核心代码体现:
 //冒泡:两两比较,较大的值往后放,第一次比较完毕,最大值出现在最大索引处;总共比较的次数:数组长度-1次
public static void bubbleSort(int[] arr){
    for(int x = 0 ;x < arr.length-1 ; x++){
        for(int y = 0 ; y < arr.length-1-x ;y++){
            //判断
            if(arr[y] > arr[y+1]){
                //中间变量
                int temp = arr[y] ;
                arr[y] = arr[y+1] ;
                arr[y+1] = temp ;
            }
        }
    }
}

代码块 :
      在java中用{}包起来的内容,称为代码块.
 分类 :
      局部代码块 : 在方法定义中使用,作用:限定局部变量的生命周期.
      构造代码块 : 在类的成员位置(类中,方法外),使用使用{}包裹起来 
                  作用:给类中的一些成员进行数据初始化                
                  特点:每次在执行构造方法之前,如果存在构造代码块,先执行构造代码块中的内容!
      静态代码块 : 在类的成员位置,直接使用 static{}.    静态代码块就加载一次!
                  作用:也可以通过static代码块,对一些操作(后期IO流创建文件/JDBC)
                  特点:随着类的加载而加载,优先于对象存在!
      //  优先级:
      //        静态代码块(只执行一次) > 构造代码块 > 构造方法

 继承 : 
      将多个类的共性内容抽取到一个独立的类中,然后这多个类和独立的这个类产生一种关系 : 继承关系
      关键字 : extends
      书写格式 :class Fu{}
               class Zi extends Fu{}
      继承的好处:
              1)提高代码的维护性
              2)提高代码的复用性
              3)让类和类之间产生的关系,是"多态的前提条件"
      继承的特点 :
              1)类与类之间的关系,继承关系,只支持单继承
              2)不支持多继承,但是可以支持多层继承
      继承中使用的注意事项 :
              1)子类继承父类 :可以继承父类的非私有的成员,私有的成员外界不能访问的,只能在本类中访问,                             但是可以通过公共方法间接访问.
              2)构造方法是不能被继承的,但是子类可以间接通过 super 关键字访问父类的构造方法.
一个类的组成 :
           成员变量
           构造方法
           成员方法
 
 继承中,每一个成员变量的关系问题
 
 成员变量 :
         a)子类继承父类,如果子类中的成员变量名称和父类的成员变量名称不一致,分别访问即可!
         b)子类继承父类,如果子类的成员变量名称和父类的成员变量名称一致:如何访问呢? (重点)
            1)首先在子类的局部位置找,是否存在局部变量名称,如果有,就使用
            2)如果没有,就在子类的成员位置找,是否存在这个变量,如果存在,就使用
            3)如果在子类的成员位置中没有找到,直接在父类的成员位置中找,如果有,就是使用!
            4)如果父类的成员位置都没有,就没有这个变量,报错!
                  // 遵循一个原则:就近原则!
继承中构造方法的访问 :
         a)子类继承父类,子类的所有的构造方法都会默认的访问父类的无参方法.
           子类的所有构造方法的第一句话:默认隐藏了super() ;  
            因为子类中肯能会使用到父类的数据,所以在继承关系中,
            得先让父类初始化---->构造方法  : 分层初始化!(先父类无参构造方法,在执行子类的构造方法)

         super:代表的父类对象的空间表示(父类对象的地址值引用!)
         b)如果父类中的无参构造方法没有,子类会怎么样?
           子类的所有的构造都会报错! (因为子类所有构造方法默认父类的无参构造方法!)
         c)如何解决呢?
              方式1:手动给出父类的无参构造方法(推荐)
              方式2:在子类的构造方法中的第一句话:通过super(xxx),间接的访问父类的有参构造方法
              方式3:只要子类的所有构造方法中一个能够让父类初始化即可!
               在子类的有参构造方法中:this():---->访问本类的无参构造方法,然后再子类的无参构造方法中
               间接访问父类的有参构造方法super(xxx) ;
 
   如何正确使用继承关系(extends)
   如果一个A类是B类的一种,或者B类是A类的一种,这个时候就可以使用继承关系
           继承关系:现实世界事物中本质体现的是一种 "is a"的关系

***总结:this和super 的区别***
       this:代表的当前类对象的地址值引用
       super:代表的父类对象的地址值引用(代表父类的空间标识)
 
       访问成员变量
           this.变量名; 访问的本类中的成员变量
           super.变量名; 访问的是父类的成员变量
 
       访问构造方法:
              this() ; 访问本类的无参构造方法
              super() ;访问的父类的无参构造方法
 
              this(xxx);访问的本类的有参构造方法
              super(xxx);访问的父类的有参构造方法
       成员方法:
               this.方法名();访问的是本类的成员方法
               super.方法名() ;访问的是父类的成员方法
 
                   
//如果子类出现了和父类一模一样的方法声明,叫做方法重写!(Override) ---方法复写(覆盖)
//方法重写和方法重载的区别?
 
  方法重载:Overload   
  在一个类中,提供n多个功能,这些功能,方法名相同,参数列表不同,与返回值无关(目的:提高某个功能的扩展性)
           参数列表不同:
                      1)类型不同
                      2)个数不同
                      3)考虑参数类型的顺序
                        public static void open(int a,double d){}
                        public static void open(double a,int b){}
                   构造方法也可以重载!
   重载的目的:为了提高功能的扩展性:同一个方法可以接收很多类型的参数
 
  方法重写:Override
  在继承关系中,子类出现了父类一模一样的方法声明,重写的目的:子类有自己的功能,需要将父类的该功能覆盖掉!
  重写的目的:为了沿用父类的功能,并且还需要使用子类的功能(具体的子类才具备具体的动作...)
                           举例:
                                 动物:
                                        都具备吃和睡的功能
                                         猫和狗都继承自动物类,他们吃的不一样的
                                         猫和狗就需要讲吃和睡的功能覆盖掉...
                                               猫具体吃鱼
                                               狗具体吃肉
关键子 : final
    final(状态修饰符):最终的,无法更改的
    关于final关键字的特点:
       1)可以修饰类,该类不能被继承!
       2)可以修饰符成员方法,成员方法不能重写!  (根据具体的题意要求!)
       3)可以修饰的变量,这个变量此时是一个常量! (自定义常量)

           
final修饰基本数据类型和引用类型的区别?
          final修饰基本数据类型: 基本数据类型的对应的数据值不能在被赋值了,只能赋值一次!
          final修饰引用类型:引用数据类型对应的地址值不能被改变
               final Student s = new Student() ;//修饰实例变量s,s的堆内存地址值永远是固定值!
                             s = new Student() ;//重新开辟空间(报错)

***多态***
          
    多态 : 一个事物在不同时刻不同形态.
        
    多态的前提条件:
           1)必须存在继承关系 (extends)
           2)必须存在方法重写
                   子类需要覆盖父类的功能
                Animal
                    eat():"动物都需要吃饭..."
                Cat
                    eat() "猫吃鱼"
                Dog
                    eat() "狗吃骨头"
 
          3)必须有父类引用指向子类对象
               class Fu{}
               class Zi extends Fu{
                   //存在重写
               }
 
               格式: Fu fu = new Zi() ;

多态成员的访问特点:
      Fu f = new Zi() ;
      成员变量:编译看左(看Fu类是否存在变量,存在,编译不会报错!)
             运行看左(使用Fu类的东西)
 
      成员方法:(一般没有明确是静态方法的都是----->非静态)
            编译看左(看Fu类是否存在这个方法,存在,编译不会报错!)
            运行看右(存在方法重写,所以最终子类的功能将父类的该功能进行覆盖!)
 
      静态的方法:
             编译看左看Fu类是否存在这个静态方法,存在,编译不会报错!),
             运行看左(静态方法:子类出现了父类一模一样的静态方法,算不上重写,跟类相关的-->类成员)                       静态功能推荐的方式:类名.访问
 
 
      构造方法:
             即使多态的情况进行测试,多态的前提条件---->继承关系
             当前执行子类的构造方法之前,需要让父类的先进行初始化,然后子类进行初始化(分层初始化!)

多态的好处:
       1)提高代码的复用性:由继承保证
 
       2)提高了代码的扩展性:由多态保证 (重点)
                   Fu fu = new Zi() ; 父类引用可以指向子类对象
           
多态的弊端:
       不能访问子类的特有功能   (Fu f = new Zi())
                       f.方法名() ;报错了. 父类中没有子类特有功能!
如何解决多态的弊端?
 
      方案1: (不推荐)
             具体的子类创建具体的子类对象  Zi z = new Zi() ;
             z.成员方法名() ;
 
             本身Fu f = new Zi() ;已经在堆内存中开辟空间了
              Zi z = new Zi() ;在堆内存中又开辟空间,从内存角度考虑,这种比较消耗内存空间,不太好!
 
      方案2:(推荐使用:"向下转型")
            多态的第三个前提条件:父类 引用指向子类对象      :"向上转型 "Fu f = new Zi() ;
            能不能将父类的引用转换成子类的引用?   好处:不需要在堆内存开辟空间
            可以------>"向下转型"
                Zi z =   (Zi)f ;  还原成子类型
 
           强转类型转换: 目标类型 变量名 =(目标类型)初始化值;
 
                  基本类型 :   int num =  65 ;
                     //num--->char类型
                  char ch  = (char)num ; ====>'A'
                      
多态的向上转型和向下转型 :
    多态的向上转型:多态的第三个前提条件--->父类引用指向子类对象    
        格式:Fu fu = new Zi() ;
        
    多态的弊端:不能访问子类的特有功能
    可以使用向下转型:
         将父类的强转强转转换为子类引用
          Zi zi = (Zi)fu;

                      
多态的方式:使用向下转型时,可能出现异常?
           要使用向下转型,前提必须有父类引用指向子类对象 Fu f = new Zi() ;
 
           遵循向下转型的格式:
                       Zi z = (Zi)f;     必须心里清楚堆内存存储的类型....
 
       向下转型使用不当,就出现java.lang.ClassCastException:类转换异常: (属于运行时期异常)
               当前堆内存中的实例不是该类型时,就会出现问题!
                   
 抽象类  :

什么是抽象类----->现实世界事物中,某个事物是比较概括性(人/水果/动物),描述为抽象事物,
  只有具体的工人/苹果/猫或者狗,才具备具体的功能;
  将某个事物中的一些功能仅仅给出声明即可,没有方法体----->抽象方法---->此时这个类必须为抽象类!
 
           举例:
                   动物都需要吃和睡
                   只要看到具体的动物类:猫类/狗类,才具备吃和睡的功能
                   将动物类中的吃和睡给出一个声明:加入一个关键字 abstract:抽象方法
                   动物类----->抽象类
 
 
     抽象的关键字:Java语言 :abstract关键字 (抽象的含义)
 
     抽象方法的格式;
       权限修饰符(一般情况都是public) abstract 返回值类型  方法名(形式参数列表) ;
 
     抽象类的格式:
     abstract  class 类名{}

抽象类的特点:
           1)有抽象方法的类一定是抽象类
           2)抽象类中不一定只有抽象方法 ,还可以非抽象方法(有方法体)
           3)抽象类不能实例化---->意思:不能创建对象
               如何实例化呢:通过具体的子类进行实例化(进行对象的创建), 抽象类多态  Fu fu = new Zi() ;Fu类型 抽象类型
           4)抽象类的子类有两种情况:
            a)目前来说:如果抽象类的子类都是抽象类---毫无意义  因为子类也不能new ,除非再有具体的子类
            b)抽象类的子类具体类---才能new     :抽象多态的形式  Fu fu = new Zi() ;

抽象类的核心宗旨:就是强制子类必须完成的事情(要将父类中的所有的抽象方法必须重写,否则报错!)
     
抽象类成员特点:
       成员变量
           既可以定义变量,也可以常量:被final修饰
       成员方法
           既可以定义为抽象方法,也可以定义为非抽象方法
           如果定义为抽象方法:关键字abstract(显示给出)
       构造方法
           存在无参构造/有参构造方法---->目的:分层初始化
               
一个类中没有抽象方法,那么将这个类定义为抽象类的意义何在?
       意义:为了不让它直接实例化!
       如何实例化:
               情况1)直接就有具体的子类
               情况2)间接的有具体的子类
                   
接口 :  
     接口---->它的本质就是体现一个现实世界事物所具有的的额外的扩展功能!
         定义格式:    interface  接口名{}  ------>接口名遵循"标识符规则"---->大驼峰命名法
 
接口中的方法:不能有方法体,隐藏public abstract关键字,只能是抽象方法,不能有方法体
 
 
接口的特点:
       1)不能实例化(不能创建对象)
       2)如何实例化
           接口实例化: 通过接口的子实现类(一定是具体类)进行实例化----接口多态(使用时最多的!)

           子实现类和接口的关系: implements 实现关系
 
 
           接口的子实现类如果是抽象类----->肯定要存在抽象类的具体的子类,否则都不能实例化!
接口的子实现类的命名规则:
       开发中--->在接口名的后面+Impl:子实现类
                       interface Inter{}
 
                       class InterImpl  implements Inter{
 
                       }
接口的成员特点:
       1)接口中的成员方法:只能是抽象方法,默认的修饰符:public abstract(可以省略不写)
       2)接口没有构造方法
       3)接口的成员变量只能是常量:
                       存在默认修饰符:public static final (可以省略不写)
                           
类与类之间的关系:  extends 继承关系
                        只支持单继承,不支持多继承,但是可以多层继承

类和接口的关系:   implements关系:实现关系
                         一个类继承另一个类的同时,可以实现多个接口,中间逗号给隔开
  
接口与接口之间:   extends:继承关系
                       不仅支持单继承,也可以多继承,中间使用逗号隔开
    
    
  形式参数问题的研究:引用类型
      
 如果方法的形式参数是类 ,调用方法的时候,如何传递实际参数?
          具体类,调用该方法,实际参数需要传递当前具体类的对象
          抽象类,调用该方法实际参数需要传递的抽象类的子类对象 (抽象类多态)
          接口  调用该方式,实际参数需要传递的是当前接口的子实现类对象(接口多态)
 
 如果一个方法的返回值是引用类型,最终方法结束,如何返回?
          具体类  :方法返回的就是当前具体类对象!
          抽象类 :需要返回的是抽象类的子类对象
          接口 :需要返回的是该接口的子实现类对象
              
关键词 : package
    包的真实含义:
               以后要代码分层...
               将包进行划分
 
           开发中,写包名的时候(字母都是小写,多级包) :公司域名反写
 
           开发中:
                   先按照模块划分,在按照功能划分
                           用户模块
                                  注册功能
                                    登录功能
                                    用户激活功能(使用邮件激活技术,手机短信验证,微信二维码)
                                    用户退出
                          商品模块
                          订单模块
                          购物车模块
                          支付模块
                       
权限修饰符:
   默认修饰符
   私有修饰符:private
   受保护的 :protected
   公共的,公开的:public

   修饰的权限从小到:private,默认,protected,public
       
内部类:
     在一个类中可以定义另一个:
 
     在类A 中定义了类B,将类B就称为类A的内部类,类A就是外部类!
 
成员内部类:
     在一个类的成员位置中定义了另一个类
 
     内部类可以访问外部类的成员,包括私有!
         
外部类如何直接访问内部类的成员方法?
       格式:
          外部类名.内部类名  对象名 = 
              外部类对象.内部类对象;

成员内部类的修饰符:
   在成员内部类上面---加入private修饰:为了数据的安全性,它的访问---就要外部类的公共访问间接访问...
         
 如果当前成员内部类是静态的,  里面的方法无论是静态的还是非静态的,都只能访问外部类的静态成员,包括私有!
 
 
 
 
  如何直接访问静态成员内部类的成员呢?
       将静态的成员内部类看成是外部类的静态成员访问
 
       直接访问方式
               外部类名.内部类名 对象名 = new 外部类名.内部类名() ;