java__基础复习02

直接排序

/*
    选择排序。
    以一个角标的元素和其他元素进行比较。
    在内循环第一次结束，最值出现的头角标位置上。
    */
    public static void selectSort(int[] arr)
    {
        for(int x=0; x<arr.length-1; x++) //比较的圈数
        {
            for(int y=x+1; y<arr.length; y++)//为什么y的初始化值是 x+1？          因为每一次比较，
                                            //都用x角标上的元素和下一个元素进          行比较。
            {
                if(arr[x]>arr[y])
                {
                    int temp = arr[x];
                    arr[x] = arr[y];
                    arr[y] = temp;
                }
            }
        }
      }

/*
    冒泡排序。
    比较方式：相邻两个元素进行比较。如果满足条件就进行位置置换。
    原理：内循环结束一次，最值出现在尾角标位置。
    */
    public static void bubbleSort(int[] arr)
    {
        for(int x=0; x<arr.length-1; x++)
        {
            for(int y=0; y<arr.length-x-1; y++)//-x:让每次参与比较的元减。
                                                //-1:避免角标越界。
            {
                if(arr[y]>arr[y+1])
                {
                    int temp = arr[y];
                    arr[y] = arr[y+1];
                    arr[y+1] = temp;
                }
            }
        }
}

折半查找(二分法)

/*
    为了提高查找效率，可使用折半查找的方式，注意：这种查找只对有序的数组有效。
    这种方式也成为二分查找法。
    */
    public static int halfSeach(int[] arr,int key)
    {
        int min,mid,max;
        min = 0;
        max = arr.length-1;
        mid = (max+min)/2;

        while(arr[mid]!=key)
        {
            if(key>arr[mid])
                min = mid + 1;
            else if(key<arr[mid])
                max = mid - 1;

            if(min>max)
                return -1;

            mid = (max+min)/2;
        }
        return mid;
    }

/*
    反转其实就是头角标和尾角标的元素进行位置的置换，
    然后在让头角标自增。尾角标自减。
    当头角标<尾角标时，可以进行置换的动作。
    */
    public static void reverseArray(int[] arr)
    {
        for(int start=0,end=arr.length-1; start<end; start++,end--)
        {
            swap(arr,start,end);
        }
    }
    //对数组的元素进行位置的置换。
    public static void swap(int[] arr,int a,int b)
    {
        int temp = arr[a];
        arr[a] = arr[b];
        arr[b] = temp;
    }

Arrays的使用

遍历： toString() 将数组的元素以字符串的形式返回
排序： sort() 将数组按照升序排列
查找： binarySearch()在指定数组中查找指定元素，返回元素的索引，如果没有找到返回（-插入点-1） 注意：使用查找的功能的时候，数组一定要先排序。

class Demo3 
{
    // 定义一个遍历二维数组的功能函数
    public static void printArr2( int [][] a ){
       // 1. 拆开二维数组
       for ( int i = 0 ; i < a.length ; i++ )
       {
           // 2. 拆开一维数组获取数据
           for ( int j = 0 ; j < a[i].length ; j++ )
           {
                System.out.print( a[i][j]+" ," );
           }
       }

    } 
    // 定义一个函数计算二维数组中的元素的累加和
    public static long getSum( int [][] a ){
       // 0. 定义一个结果变量
        long sum = 0L;
       // 1. 拆开二维数组
       for ( int i = 0 ; i < a.length ; i++ )
       {
           // 2. 拆开一维数组获取数据
           for ( int j = 0 ; j < a[i].length ; j++ )
           {
                sum+=a[i][j];
           }
       }
       return sum;
    } 

    // 统计二维数组中元素的个数
    public static int getDataCount( int [][] a ){
       // 0. 记录元素个数
       int  count = 0;
       // 1. 拆开二维数组
       for ( int i = 0 ; i < a.length ; i++ )
       {
           // 2. 拆开一维数组获取数据
           for ( int j = 0 ; j < a[i].length ; j++ )
           {
                count++;
           }
       }
      return count;
    } 
    public static void main(String[] args) 
    {

        int [][] a = new int[][]{ {23,4,5},{2},{4,5,78,56,90} };
        printArr2( a );
        System.out.println();
        System.out.println("累加和是： "+getSum( a ) );
        System.out.println("统计元素个数： "+getDataCount( a ) );
        System.out.println("Hello World!");


    }
}

函数的重载

函数重载的定义：在同一个类中，有一个以上的同名函数，只要函数的参数列表或参数类型不一样即可，与返回值无关， 这些统称为方法的重载。

面向对象与面向过程对比

“万物皆对象”。
1：买电脑
1：面向过程
1：查资料
2：电脑城砍价
3：被黑
4：痛苦归来
1：面向对象
1：找对象。老师
2：老师.砍价
3：老师.检测电脑
4：电脑成功购买
2：吃饭
1：面向过程
1：自己动手做
2：买菜
3：洗菜
4：煮饭炒菜
5：很难吃，浪费时间
2：面向对象
1：找专业对象
2：餐馆.点餐
3：餐馆，做饭
4：饭好吃，节约时间，精力
4：找对象
1：求介绍，相亲，找现成的对象。（面向对象的思想先找有的对象，直 接拿来使用）
2：不满意，没有对象，自己造一个。（sun没有提供，自己造对象）
再例如：人开门，人开电视，人画园。

匿名对象
匿名对象：没有名字的实体，也就是该实体没有对应的变量名引用。
2.2匿名对象的用途
1，当对象对方法进行一次调用的时候，可以使用匿名对象对代码进行简化。
为什么只对方法，而不调用属性呢？因为匿名对象调用属性没意义。
如果对象要多成员进行多次调用，必须给对象起个名字。不能在使用匿名 对象。
2，匿名对象可以实际参数进行传递。
2：匿名对象的简单演示
1：new Car().run();
3：内存结构图
1：new Car().num=5;
2：new Car().clor=”blue”;
两个new 是两个不同的对象，在堆内存中有不同的空间，相互不相互干扰。
4：匿名对象的使用
1：当只使用一次时可以使用匿名对象。执行完毕到;后该对象就变成了垃圾。
new Car().run();
2:执行方法时，可以将匿名对象作为实际参数，传递进去。

总结：
1. 匿名对象设置的属性永远无法获取？ 没有引用变量指向那个对象。
2. 任何两个匿名对象使用==比较，永远返回false。
3. 匿名对象主要应用于实参。

封装的好处

1：隐藏了类的具体实现
2：操作简单
3：提高对象数据的安全性

构造函数与普通的函数的区别

1.一般函数是用于定义对象应该具备的功能。而构造函数定义的是，对象在调用功能之前，在建立时，应该具备的一些内容。也就是对象的初始化内容。
2.构造函数是在对象建立时由jvm调用, 给对象初始化。一般函数是对象建立后，当对象调用该功能时才会执行。
3.普通函数可以使用对象多次调用，构造函数就在创建对象时调用。
4.构造函数的函数名要与类名一样，而普通的函数只要符合标识符的命名规则即可。
5.构造函数没有返回值类型。
3.3构造函数注意的细节
1. 当类中没有定义构造函数时，系统会指定给该类加上一个空参数的构造函数。这个是类中默认的构造函数。当类中如果自定义了构造函数，这时默认的构造函数就没有了。
备注：可以通过javap命令验证。
2.在一个类中可以定义多个构造函数，以进行不同的初始化。多个构造函数存在于类中，是以重载的形式体现的。因为构造函数的名称都相同

构造代码块

构造代码块作用：给所有的对象进行统一的初始化。
作用
1：给对象进行初始化。对象一建立就运行并且优先于构造函数。
2：与构造函数区别
1：构造代码块和构造函数的区别，构造代码块是给所有对象进行统一初始化， 构造函数给对应的对象初始化。
2：构造代码块的作用：它的作用就是将所有构造方法中公共的信息进行抽取。
例如孩子一出生统一哭

this

总结：实际工作中，存在着构造函数之间的相互调用，但是构造函数不是普通的成员函数，不能通过函数名自己接调用,所以sun公司提供this关键字。
this是什么
1：this代表所在函数所属对象的引用
2:this只能在非静态中（没有static修饰的）函数使用
3：构造函数间相互调用必须放在构造函数的第一个语句中，否则编译错误
4：可以解决构造函数中对象属性和函数形参的同名问题。

static

1：为了实现对象之间重复属性的数据共享
static使用
1：主要用于修饰类的成员
1：成员变量
1：非静态成员变量：需要创建对象来访问
2：静态成员变量：使用类名直接调用，也可以通过对象访问
2:成员方法
可以使用类名直接调用
1：静态函数：
1：静态函数中不能访问非静态成员变量，只能访问静态变量。
2：静态方法不可以定义this,super关键字.
3：因为静态优先于对象存在.静态方法中更不可以出现this
2：非静态函数：非静态函数中可以访问静态成员变量

静态代码块特点

随着类的加载而加载。只执行一次，优先于主函数。用于给类进行初始化。

重写(覆盖 override)

1： 在继承中，子类可以定义和父类相同的名称且参数列表一致的函数，将这种函数
称之为函数的重写.
4：前提
1：必须要有继承关系
5：特点
1：当子类重写了父类的函数，那么子类的对象如果调用该函数，一定调用的是重写过后的函数。
可以通过super关键字进行父类的重写函数的调用。
2： 继承可以使得子类增强父类的方法
6：细节
1： 函数名必须相同
2：参数列表必须相同
3： 子类重写父类的函数的时候，函数的访问权限必须大于等于父类的函数的访
问权限否则编译报错
4：子类重写父类的函数的时候，返回值类型必须是父类函数的返回值类型或该返回值类型的子类。不能返回比父类更大的数据类型： 如子类函数返回值类型是Object

instanceof是什么？

1：属于比较运算符：
2：instanceof关键字：该关键字用来判断一个对象是否是指定类的对象。
3：用法：
对象 instanceof 类;
该表达式是一个比较运算符，返回的结果是boolea类型 true|false
注意：使用instanceof关键字做判断时，两个类之间必须有关系。

抽象类

1：当描述一个类的时候，如果不能确定功能函数如何定义，那么该类就可以定义为抽象类，功能函数应该描述为抽象函数。
6：抽象类的特点
1：有抽象函数的类，该类一定是抽象类。
2：抽象类中不一定要有抽象函数。
3：抽象类不能使用new创建对象
1：创建对象，使用对象的功能，抽象类的方法，没有方法体。
4：抽象类主要为了提高代码的复用性，让子类继承来使用。
5：编译器强制子类实现抽象类父类的未实现的方法。
1：可以不实现，前提是子类的也要声明为抽象的。
7：抽象的优点
1：提高代码复用性
2：强制子类实现父类中没有实现的功能
2：提高代码的扩展性，便于后期的代码维护
8：抽象类不能创建对象，那么抽象类中是否有构造函数？
1：抽象类中一定有构造函数。主要为了初始化抽象类中的属性。通常由子类实现。
9：final和abstract是否可以同时修饰一个类？
一定不能同时修饰。

模板设计

接口(interface)

usb接口，主要是使用来拓展笔记本的功能，那么在java中的接口主要是使用来拓展定义类的功能，可以弥补java中单继承的缺点。
1.接口中的所有属性 默认的修饰符是 public static final。
2.接口中的所有方法 默认的修饰符是 public abstract。

1.类实现接口可以通过implements实现，实现接口的时候必须把接口中的所有方法实现,一个类可以实现多个接口。
2.接口中定义的所有的属性默认是public static final的，即静态常量既然是常量，那么定义的时候必须赋值。
3.接口中定义的方法不能有方法体。接口中定义的方法默认添加public abstract
4.有抽象函数的不一定是抽象类，也可以是接口类。
5.由于接口中的方法默认都是抽象的，所以不能被实例化。
6.对于接口而言，可以使用子类来实现接口中未被实现的功能函数。
7.如果实现类中要访问接口中的成员，不能使用super关键字。因为两者之间没有显示的继承关系，况且接口中的成员成员属性是静态的。可以使用接口名直接访问。
8.接口没有构造方法。
接口与接口之间的关系是继承，接口可以多继承接口.

多态总结

1：当父类和子类具有相同的非静态成员变量，那么在多态下访问的是父类的成员变量
2：当父类和子类具有相同的静态成员变量，那么在多态下访问的是父类的静态成员变量
所以：父类和子类有相同的成员变量，多态下访问的是父类的成员变量。
3：当父类和子类具有相同的非静态方法（就是子类重写父类方法），多态下访问的是子类的成员方法。
4：当父类和子类具有相同的静态方法（就是子类重写父类静态方法），多态下访问的是父类的静态方法。
2：多态体现
1：父类引用变量指向了子类的对象
2：父类引用也可以接受自己的子类对象
3：多态前提
1：类与类之间有关系，继承或者实现
4：多态弊端
1：提高扩展性，但是只能使用父类引用指向父类成员。
5：多态特点
非静态
1：编译时期，参考引用型变量所属的类是否有调用的方法，如果有编译通过。没有编译失败
2：运行时期，参考对象所属类中是否有调用的方法。
3：总之成员函数在多态调用时，编译看左边，运行看右边。
在多态中，成员变量的特点，无论编译和运行参考左边（引用型变量所属的类）。
在多态中，静态成员函数特点，无论编译和运行都参考左边

内部类

在一个类中，定义在类中的叫成员变量，定义在函数中的叫成员函数，那么根据类定义的位置也可以分为成员内部类和局部内部类。
备注：内部类生产的class文件为 “外部类$内部类”，为了标明该内部类是属于具体哪个外部类的。

1.2成员内部类的访问方式
1.内部类可以直接访问外部类的成员属性。(孙悟空相当于内部类飞到牛魔王的肚子里面去)。
2.外部类需要访问内部类的成员属性时需要创建内部类的对象。
1.在外部类的成员函数中创建内部类的对象，通过内部类对象对象直接访问内部类的成员。
2.在其他类中直接创建内部类的对象。
Outer.Inner inner = new Outer().new Inner();

疑问： 什么时候使用内部类呢？
当我们分析事物时，发现事物的内部还有具体的事物，这时则应该定义内部类了。
比如人体是一个类，人体有心脏，心脏的功能在直接访问人体的其他内容。这时就将心脏定义在人体类中，作为内部类存在。
内部类的优势：成员内部类作为外部类的成员，那么可以访问外部类的任意成员。

如果内部类中包含有静态成员，那么java规定内部类必须声明为静态的访问静态内部类的形式：Outer.Inner in = new Outer.Inner();

局部内部类

局部内部类概述：包含在外部类的函数中的内部类称之为局部内部类。
访问：可以在包含局部内部类的方法中直接创建局部内部类的对象调用局部内部类的成员。
注意：局部内部类只能访问所在函数的fanal属性。

匿名内部类

匿名内部类：就是没有类名字的内部类。
匿名内部类作用：简化内部类书写。
匿名内部类的前提:必须继承一个父类或者是实现一个接口。
匿名内部类的格式： 
    new 父类或者接口(){ 执行代码….};
内部类的写法：
class Outer{
    class Inner
    {
        public void show(){
            System.out.println("内部类的show方法");
        }
    }
    public void print(){
        new Inner().show();
    }
}

匿名内部类调用show方法:

在外部类调用show1、show2方法。内部类的实现方法/

使用匿名内部类实现：

注意细节：
1.使用匿名内部类时，如果需要调用匿名内部类的两个方法或者两个方法以上。可以使用变量指向该对象。

2.2java异常体系图

java中可以通过类对这一类不正常的现象进行描述，并封装为对象。
1.java的异常体系包含在java.lang这个包默认不需要导入。
2.java异常体系

2.3Throwable类
1.toString() 输出该异常的类名。
2.getMessage() 输出异常的信息，需要通过构造方法传入异常信息（例如病态信息）。
3.printStackTrace() 打印栈信息。

1.try{//可能发生异常的代码 }catch(异常类 变量名){//处理}。

多个异常:
1.使用将可能发生异常的代码放入try语句中，添加多个catch语句即可。
2.可以处理多种异常，但是同时只能处理一种异常。
3.try中除0异常和数组角标越界同时出现，只会处理一种。

throw和throws的区别

1.相同：都是用于做异常的抛出处理的。
2.不同点：
1.使用的位置: throws 使用在函数上，throw使用在函数内
2.后面接受的内容的个数不同:
1.throws 后跟的是异常类，可以跟多个，用逗号隔开。
2.throw 后跟异常对象。

自定义异常

/*
 自定义异常  
 */
class NoIpException extends Exception {

    NoIpException() {

    }

    NoIpException(String message) {
        super(message);
    }

}

class Demo10 {

    public static void main(String[] args) throws NoIpException {

        System.out.println();
        String ip = "192.168.10.252";
        ip = null;
        try {
            Lb(ip);
        } catch (NoIpException e) {
            System.out.println("程序结束");
        }

    }

    /*
     * 
     * 凌波教学
     */
    public static void Lb(String ip) throws NoIpException {
        if (ip == null) {
            // throw new Exception("没插网线吧，小白");
            throw new NoIpException("没插网线吧，小白");
        }

        System.out.println("醒醒了，开始上课了。");
    }
}

运行时异常和非运行时异常

RunntimeException的子类：
ClassCastException
多态中，可以使用Instanceof 判断，进行规避
ArithmeticException
进行if判断，如果除数为0，进行return
NullPointerException
进行if判断，是否为null
ArrayIndexOutOfBoundsException
使用数组length属性，避免越界
这些异常时可以通过程序员的良好编程习惯进行避免的
1：遇到运行时异常无需进行处理，直接找到出现问题的代码，进行规避。
2：就像人上火一样牙疼一样，找到原因，自行解决即可
3：该种异常编译器不会检查程序员是否处理该异常
4：如果是运行时异常，那么没有必要在函数上进行声明。

finally

1: 实现方式一：
try{ // 可能发生异常的代码 } catch( 异常类的类型 e ){ // 当发生指定异常的时候的处理代码 }catch…
比较适合用于专门的处理异常的代码，不适合释放资源的代码。
2：实现方式二：
try{ } catch(){} finally{ // 释放资源的代码 }
finally块是程序在正常情况下或异常情况下都会运行的。
比较适合用于既要处理异常又有资源释放的代码
3：实现方式三
try{ }finally{ // 释放资源 }
比较适合处理的都是运行时异常且有资源释放的代码。
4：finally:关键字主要用于释放系统资源。
1：在处理异常的时候该语句块只能有一个。
2：无论程序正常还是异常，都执行finally。
5：finally是否永远都执行？
1：只有一种情况，但是如果JVM退出了System.exit(0)，finally就不执行。
2：return都不能停止finally的执行过程。

Jar包

jar就是打包文件
jar文件时一种打包文件java active File,与zip兼容，称之为jar包
开发了很多类，需要将类提供给别人使用，通常以jar包形式提供.当项目写完之后，需要及将class字节码文件打包部署给客户。如何打包？可以使用jar命令.
2：jar命令
1：jar工具存放于jdk的bin目录中(jar.exe)
2：jar工具：主要用于对class文件进行打包(压缩)
3：dos中输入jar查看帮助
3：案例使用jar命令
将day10中的cn文件打包为名字为test.jar文件(cn 文件是使用javac -d 编译带包的class文件夹)
jar cvf test.jar cn
详细命令:
1：jar cf test.jar cn 在当前目录生成test.jar 文件，没有显示执行过程
2：jar cvf test.jar cn 显示打包中的详细信息
3：jar tf test.jar 显示jar文件中包含的所有目录和文件名
4：jar tvf test.jar 显示jar文件中包含的所有目录和文件名大小，创建时间详
细信息
5：jar xf test.jar 解压test.jar到当前目录，不显示信息
6：jar xvf test.jar 解压test.jar到当前目录，显示详细信息
7：可以使用WinRaR进行jar解压
8；将两个类文件归档到一个名为 test2.jar 的归档文件中：
jar cvf test2.jar Demo3.class Demo4.class
9：重定向
1：tvf可以查看jar文件内容，jar文件大，包含内容多，dos看不全。
2：查看jdk中的rt.jar 文件 jar tvf rt.jar
3：jar tvf rt.jar>d:\rt.txt