java面向对象学习

一：什么是类 什么是对象
1.1现实世界是有不少对象组成的，基于对象抽出了类
1.2对象是真实存在的单个的个体，类是一类个体，类型/类别
1.3类中能够包括：

全部对象所共有的特征属性----变量
    全部对象所共有的行为--------方法

1.4一个类能够建立多个对象，同一个类的多个对象，机构相同，数据不一样
1.5类 是对象的模板，对象是类的具体的实例

二：内存管理
由jvm来管理

1.1用于存储全部new出来的对象（包括成员变量）
    1.2成员变量的生命周期;建立new对象时存在在堆中，对象被GC回收时一并消失
    1.3垃圾：没有任何引用所指向的对象
        垃圾回收器GC不定时到内存中扫描，看到垃圾不必定立刻回收    
        回收过程是透明的，并非一看到垃圾就立刻回收，想快一点能够调用System.gc()
    1.4局部变量：调用方法时存在在栈中，方法结束时与之一并消失
    1.5方法区：
        用于存储.class字节码文件（包括方法）
        方法只有一份，经过this来区分具体是哪一个

继承
2.1目的：避免代码重复，有利于代码的复用
2.2经过extends实现继承
2.3父类/基类：全部子类所共有的属性和行为 子类：子类所特有的属性和行为
2.4子类/派生类继承父类后，子类具备：子类+父类
2.5一个父类能够有多个子类，一个子类只能有一个父类-----单一继承
2.6继承具备传递性
2.7java规定：

构造子类方法以前必须先构造父类方法
        子类构造以前没有调用父类的构造，系统默认super（）来调用父类的无参构造
        若本身调用了，则再也不默认提供
        super（）调用父类构造，必须位于子类构造的第一行

super：指代当前对象的父类对象

1：super.方法名（）-----调用父类的方法
    2：super.成员变量名-----调用父类的成员变量
    3：super（）------------调用父类的构造方法
向上造型：
    1：父类型的引用指向子类的对象
    2：能点什么得看引用类型

三：方法
方法：方法的签名：方法名+参数列表

1.方法的重载overload：同一个类中，方法名称相同，参数列表不一样
              编译器在编译时自动根据方法的签名来绑定调用方法


2.构造方法（构造器，构造函数，构建器）
    经常用于给成员变量赋初值
    与类同名，没有返回类型    
    在建立（new）对象时被自动调用
    若本身不写构造方法，则编译器默认提供无参结构的构造方法
    构造方法能够重载
3.this：指代当前对象，那个对象调用指的就是哪一个对象
    方法中访问成员变量以前默认都有个this
   this的用法
    this.成员变量名-------访问成员变量
    this.（方法名）-------调用方法；
    this（）--------------调用构造方法

4.引用类型数组：
    4.1    
        cell[] cells = new cell[4];
        cells[0] = new cell(2,1);
        cells[1] = new cell(2,8);
        cells[2] = new cell(5,5);
        cells[3] = new cell(3,5);

    4.2    
        cell[] cells = new cell[]{
            new cell(2,1);
             new cell(2,8);
             new cell(5,5);
             new cell(3,5);

        }

    4.3    int [][] arr = new int [3] [];
          arr[0] =new int [2];
          arr[1] =new int [3];
          arr[2] =new int [2];
        arr[1][0] = 100;

    4.4     int [][]arr = new int [3][4];
        for(int i = 0;i<arr.length;i++){
            for(int j = 0;j<arr[i].length;j++){
                arr[i][j] = 100;
            }
        }
1.方法的重写override
    1.1发生在父子类中，方法名相同，
2.重写与重载的区别
    2.1
    2.2重载：一个类中，方法名相同，参数列表不一样
        遵循“编译期”绑定，根据引用的类型绑定
3.package
    3.1做用、；避免类的命名冲突；
    3.2包名能够有层次结构
    3.3建议包名全小写
    3.4类的彻底限定名：包名.类名
  import：
    3.11做用：声明类/引入类
    3.22同包中的类能够直接访问
    3.33：不一样包中的类要访问得先import声明类在访问
4.访问修饰符：
    4.1public：公开的，任何类
    4.2private：私有的，本类
    4.3protected：受保护的，本类，子类，同包类
    4.4默认的什么也不写：本类，同包类
    类发访问修饰：public和默认的
    类成员的访问修饰：如上四种皆可


    建议数据私有化private ， 行为公开化public

static：静态的

1静态变量
        由static修饰
        属于类的，存在方法区中，只有一份
        经常经过类名. 来访问
        什么时候用：若全部对象的数据都同样时使用
    2静态方法

        由static修饰
        属于类的，存在方法区中，只有一份
        经常经过类名. 来访问
        没有隐式的this来传递；静态方法中不能直接访问实例成员
        什么时候用：方法的操做仅与参数相关而与对象无关
        
    3静态块
        由static修饰
        属于类的，类被加载时自动执行，类只被加载一次，因此静态块也只执行一次
        什么时候用：经常用于加载静态资源图片音视频等
        

*成员变量：
1.实例变量：属于对象的，存在堆中；
        有几个对象就有几个实例变量；
        必须经过对象名.来访问
2.静态变量：
    由static修饰，属于类的，存在方法区中
    只有一份
    经常经过类名. 来访问
    
6.final：不能变
    6.1修饰变量：变量不能被改变
    6.2修饰方法：方法不能被重写
    6.3修饰类：类不能被继承


7.static final常量
    7.1必须声明的同时初始化
    7.2经过类名.来访问，不能改变
    7.3建议常量名都大写
    7.4在编译的同时会自动转换为具体的值，效率高



1.抽象方法：由abstract修饰，只有方法的定义没有方法的实现
2.抽象类：
    2.1由abstract修饰
    2.2包含抽象方法的类必须是抽象类
    2.3抽象类不能被实例化
    2.4抽象类是须要被继承的，不然无心义，经常使用-----重写全部抽象类的方法
    2.5意义：
        2.5.1包含公共的属性和行为，被子类所共享
        2.5.2为全部子类所提供一种公共的类型----向上造型
        2.5.3包含抽象方法，为全部子类提供一个统一的方法，子类有不一样的实现

接口：

//接口是彻底抽象的抽象类
    1是一个标准、规范
    2由interface定义
    3只能包含常量和抽象方法，略的是public
    4接口是不能被实例化的
    5接口是须要被实现/继承的，实现类/子类：
                    必须重写接口中全部的抽象方法
    3.6一个类能够实现多个接口，用逗号隔开，若又继承又实现，要先extends后implements
    3.7接口能够继承接口

多态：意义：

1.1同一类型的引用指向不一样的对象时，有不一样的实现
    1.2强制类型转换，成功的条件有两个：
        引用所指向的对象，就是该类型
        引用所指向的对象，实现了该接口
    1.3instanceof关键字返回的是boolean类型结果，强转成功的条件就是它为true的条件

内部类，有本身独立的.class

1成员内部类
        只服务于外部类，他的对象通常是在外部类建立的
        内部类中能够直接访问外部类的成员包括private
        内部类中有个隐式的引用指向建立他的外部类

    2匿名内部类
        经常使用
        想建立一个只用一次的类的对象，该类可没必要命名
        匿名内部类中访问外部的数据，该数据必须final类型

面向对象总结

面向对象的三大特征：
1.封装

1.1 类：封装的是对象的属性和行为
1.2 方法：封装的是具体的逻辑功能实现
1.3访问控制修饰符：封装的是访问的权限

2.继承：

2.1做用：避免代码的重复，有利于代码的重用
2.2父类：全部子类所共有的  子类:特有的   子类extends继承后：子类+父类
2.3单一继承，多接口实现，具备传递性

3.多态

3.1意义：行为的多态、对象的多态
3.2向上造型、强制类型转换、instanceof
3.3多态的表现形式：    
    重写+重载