Java 基础一（面向对象）

　　前面罗嗦几句吧，直接上正文好像显得没有多少生气，这个基础是之前在学校时总结的，东西比较杂，有些知识点也只是点到为止，请各位看官见谅，当时能力有限，但是我现在也不会修改太多，最多就是修改下文字格式和错别字，主要是因为这是我的成长见证，我要记录保存下来。好了废话不多说，上菜！

 

面向对象

1.1面向对象

 面向对象是针对面向过程来说的，强调的是对象（将功能行为封装到对象里）

1.2类和对象

类是对象的抽象表象，类似设计图纸

对象是类在jvm内存中的实例，通过new + 构造器来创建实例

1.3匿名对象

 某个类的某个方法只需执行一次时，将匿名对象作为实例传递给一个方法调用

1.4类的成员

属性（成员变量）

变量的分类：

　　按位置不同：
　　　成员变量
            定义在类中方法外
                  实例变量
                  类变量 使用static修饰的
     局部变量
            定义在方法内
            定义在代码块内                                

 

区别：

1、定义位置不同
      1）成员变量
          定义在类中方法外
      2）局部变量
　　　　　　定义在方法内
　　　　　　定义在代码块内
2、在内存的位置不同
　　　 1）成员变量
　　　　　　堆中
　　　 2）局部变量
　　　　　　栈中
3、生命周期不同
　　　1）成员变量
　　　　　　生命周期和类的实例一样
　　　2）局部变量
　　　　　　随着方法的执行完成，就被回收了
　　　　　　例如：方法，代码执行完毕
4、初始化方式不同
　　　1）成员变量
　　　　　　可以被默认初始化
　　　2）局部变量
　　　　　　必须显示初始化
5、编写方式不同
　　　1）成员变量
　　　　　　可以使用任意权限修饰符修饰
　　　2）局部变量
　　　　　　不能有修饰符        

方法

定义格式（请记住方法五要素）：
修饰符 返回值类型 方法名(参数类型 参数1, 参数类型 参数2, ...){
　　　　方法体;
　　　　return 返回值;
}

构造器

特征：
　　1、与类名相同
　　2、不能声明返回值类型，连void都不行
　　3、不能被static、final、synchronized、abstract、native修饰
　　4、不能有return语句
作用：
　　1、创建对象
　　2、给对象成员变量初始化
定义格式：
　　修饰符 类名(参数列表){
　  　　初始化语句;
 　}
特点：
　　1、每个类至少有一个构造器，如果你没有定义，系统会默认一个无参构造器
　　2、构造器的默认修饰权限和类的修饰权限一样
　　3、一旦你手工指定了有参构造器，系统就不会再提供默认构造器
　　4、构造器可以重载
　　5、父类的构造器不可被子类继承

2.GC机制

 

3.this 关键字

this代表当前对象：在普通方法里代表的是当前对象所属方法的引用，在构造方法里代表的是要实例化的对象。
可以调用类的属性、方法和构造器

调用属性：this.属性
调用方法：this.方法
调用用构造器：
    1、只能在构造器调用其他构造器
    2、使用方式：this(...)
    3、this访问构造器时，必须在构造器的首行出现，且只能调用一次
注意：
　　当成员变量和局部变量的变量名冲突时，可以使用this来区分
　　因为java变量使用有就近原则

4.javabean

1.类是公共的 public 
2.有一个无参的公共的构造器
3.有私有属性，且有对应的set 、get方法

5.继承 

多个类中存在相同属性和行为时，将这些内容抽取到单独的一个类中，其他类就不需要再写这些属性和行为，只需继承就行. 
继承的规则：
　　子类不能继承父类私有成员
　　子类不能继承父类的构造方法
　　Java只支持单继承，不允许多重继承

6.方法的重写

必须有继承或实现
重写注意事项：
　　1、覆盖方法必须和被重写方法具有相同的方法名称、参数列表和返回值类型。
　　2、重写的方法权限不能比被重写的小
　　3、两者都不能是static
　　4、抛出的异常不能大于被重写方法抛出的异常

7.多态

 多态是一个对象在不同时刻表现出的不同状态，例如一个对象的引用指向他的父类，或指向他自己

 java引用类型：编译时类型和运行时类型
 一旦编译时类型和运行时类型时类型不一致，就会产生多态
 
 多态三要素：
     1.要有继承或实现
     2.重写
     3.父类的引用指向子类
 
 多态中的成员访问特点：
    成员变量：
        编译时看等号左边，运行时也要看左边
    构造方法
        子类实例化的时候，会访问父类的构造方法，要对父类的成员变量初始化
    成员方法：
        编译是看左边有没有（没有就会报错），运行时看右边（执行的是子类重写的方法）

8.static 关键字         

static可以修饰成员变量，成员方法，代码块，内部类
static修改的成员的特点：
　　随着类的加载而加载
　　优先于对象存在
　　修饰的成员，被所有对象所共享
　　访问权限允许时，可以直接通过类调用
注意：
    静态方法不能访问非静态成员(变量，方法)，也就是静态只能访问静态
    非静态的方法可以任意访问成员
static与this:
在静态方法中是不能使用this关键字的，为什么？
    因为静态成员是随着类的加载而初始化的，优先于对象存在
    this是随着对象的创建(new)而出现的

9.代码块

初始化块（代码块）分为：

成员代码块
　　{}，写在类中方法外
局部代码块
　　{}，写在方法内
静态代码块
　　static{}，使用static修饰的成员代码块

子类实例化过程：

    public class CodeBlock02 {

        public static void main(String[] args) {

            new Zi().show();

        }
    }

    class Fu{

        static int a;

        static{
            a=100;
            System.out.println("我是父亲的静态代码块");
        }
        {
            System.out.println("我是父亲的成员代码块");
        }

        Fu(){
            System.out.println("我是父亲的无参构造方法");
        }

    }

    class Zi extends Fu{

        static int a;

        static{
            a=200;
            System.out.println("我是儿子的静态代码块");
        }
        {
            System.out.println("我是儿子的成员代码块");
        }

        Zi(){
            System.out.println("我是儿子的无参构造方法");
        }

        void show(){
            System.out.println(a);
        }

    }

执行的顺序：

我是父亲的静态代码块
我是儿子的静态代码块
我是父亲的成员代码块
我是父亲的无参构造方法
我是儿子的成员代码块
我是儿子的无参构造方法
200

10.final 关键字

final关键字的特点：
　　final修饰的类，不能不能继承
　　final修饰的方法，不能被重写
　　final修饰的变量，叫常量，只能被赋值一次。
　　　　要么就在定义的时候赋值
　　　　要么就在构造方法结束前赋值
常量：
　　字面值常量
　　　　100,"java",true
自定义常量
　　final int a = 100;
注意：final修饰的常量要进常量池

11.返回值类型和参数类型问题

返回值类型
    基本类型：八种基本类型（byte、short、int、long、boolean、char、float、double）
    引用类型
        类：返回的该类的对象
        抽象类：返回的是该类的子类的对象   
        接口
形式参数：
　　基本类型：八种基本类型
　　引用类型：
　　　　类：需要是该类的对象
　　　　抽象类：子类的对象
　　　　接口 ：子类的对象

注意：参数是基本类型和引用类型的区别
    基本类型
        形参的值发生变化，不会影响实参的值
    引用类型
        形参数的值发生变化，会影响实参的值

12.排序

冒泡排序

数据排序：

　　就是将数组的数组进行有序排列：例如int[] score = {80,75,90,87,99,68};

　　排序后结果：{68,75,80,87,90,99}

冒泡排序：

　　核心思想是进行数据两两比较，每次找到最大值往后面放，这样每一轮能找出一个最大值，放在末尾。

　　然后进行数组长度-1轮就能完成排序

代码示例：

    public static void main(String[] args) {
        //定义成绩数组，要求从小到大排序
        int[] score = {80,75,90,87,99,68};
        System.out.print("排序前：");
        printArray(score);
        //从画图分析来看，我们知道冒泡排序共需要数组长度减1轮排序
        for (int i = 0; i < score.length-1; i++) {
            //每一轮排序的次数是数组长度减1再减i
            for (int j = 0; j < score.length-1-i; j++) {
                //定义临时变量，用于暂存数据
                int temp = 0;
                //两两比较
                if(score[j]>score[j+1]){
                    //将小的放到临时变量上
                    temp = score[j+1];
                    //再将大的覆盖小的
                    score[j+1]=score[j];
                    //最后把小的放到前面
                    score[j]=temp;
                }
            }
        }
        System.out.println();
        System.out.print("排序后：");
        printArray(score);
    }

    public static void printArray(int[] array){
        for (int i = 0; i < array.length; i++) {
            if(i==array.length-1){
                System.out.print(array[i]);
            }else{
                System.out.print(array[i]+",");
            }
        }
    }

二分查找

数据查找算法（二分法，折半查找）

前提条件：

　　数组是有序数组，例如：{68,75,80,87,90,99}

原理：

　　取数组中间的一个数和目标数据进行比较中间数比目标数大那么就在中间数的前面找中间数比目标数小那么就在中间数的后面找

代码示例：

    /**
     * 二分查找算法
     *
     *
     *
     * @param array
     * @param target
     * @return
     */
    public static int binarySearch(int[] array, int target){

        int mid = 0;

        int begin = 0;
        int end = array.length-1;
        while(begin<=end){

　　　　　　//取到数组中间数
            mid = (begin+end)/2;
　　　　　　//如果找到目标值
            if(target == array[mid]){
                return mid;
            }
            else if(target > array[mid]){
                begin=mid+1;
            }
            else{
                end = mid-1;
            }

        }

        return -1;
    }
 

选择排序

   原理：选定一个位置的元素,拿这个位置的元素和后面的每一个元素进行比较,满足条件 交换位置

    @Test
    public void XuanZe() throws Exception {

        int[]a =new int[]{88,9,11,22,55,33,66,44,77}; //a[i] i+1 j<10

　　　　// i:排序的遍数 也表示选定的位置
        for (int i = 0; i < a.length-1; i++) {
            // 每一遍比较的过程:后面的每一个元素
            for (int j =i+1; j < a.length; j++) {
                // 满足条件 交换位置
                if(a[i] < a[j]){
                    int temp=a[i];
                    a[i]=a[j];
                    a[j]=temp;
                }
            }

        }
        System.out.println("---------");
        for (int i : a) {
            System.out.println(i);
        }

    }

递归算法

递归：方法调用他本身的现象，就叫递归

注意：

1、递归调用一定要有出口，没有出口就是死递归

2、递归的次数不能太多，否则会出现StackOverflowError

3、构造方法不能递归

   public class DiGui {

　　　　 //测试递归算法（查看一个文件下面的所有文件名）
        List<String> listN=new ArrayList<String>(); //也可以写成File类型
        @Test
        public void test() throws Exception {
            List<String> l = digui(new File("f:/笔记"), listN);
            for (String string : l) {
                System.out.println(l);
            }
        }

        public List<String> digui(File file,List<String > list){

            if(file.isDirectory()){
                File[] f = file.listFiles();
                for (File file2 : f) {
                    digui(file2,list);
                }
            }else {
                list.add("===="+file.getName()+"===文件");
            }

            return list;

        }

    }

关于递归

//输入一个小于1000000的整数，分别用100,50,20,10,5,2,1 表示出来，有多少种表示法，写出算法即可

 public class DiGui2 {
        int i = 0;
        int[] aaa={100,50,20,10,5,2,1};
        public static void main(String[] args) {

            DiGui2 diGui2 = new DiGui2();
            diGui2.count(500,0,"");
            System.out.println("一共===="+diGui2.i+"种算法");
        }

        public void count(int a,int xx,String result){

            if(a<0){
                return;
            }
            if(a==0){
                i++;
                System.out.println(result);
            }

            if(a<1000000){
                for (int j = xx; j < aaa.length-1; j++) {
                    count(a-aaa[j],i,result+" "+aaa[i]);
                }
            }
        }

13.Arrays

数组工具类：Arrays。
sort()：用来对array进行排序。 
binarySearch()：在排好序的array中寻找元素。