java

day1

软件（Software）是一系列按照特定顺序组织的计算机数据和指令的集合
人机交互两种方式：图形交互，命令交互。
java的特点：安全可靠，面向对象，跨平台(与平台无关，可以运行在任何操作系统之上)
java的三个版本：javaME(过时了)，javaSE(standard editon 即标准版本)，javaEE(enterprise edition 即企业版本)
java如何实现跨平台的：因为有JVM(java虚拟机)，java程序是由JVM来运行的，JVM是跨平台的，所以java程序是跨平台的。安装jdk时就包含了JVM
       下载JDK时，选择相应操作系统的JDK。
jre：java runtime environment(java运行时环境)，运行java程序时需要的资源在jre中，
jdk和jre的关系：jdk包括了jre
jre和jvm的关系：jre包括了jvm 
 jdk>jre>jvm
jdk:java development kit(java开发工具包)：编写java程序时需要的资源在jdk中，
安装软件下的目录：
 bin：(binary)二进制，存放可执行文件，其文件夹下的java.exe和javac.exe是经常使用的程序：
  使用方式：1.切换到c盘；2.切换到jdk下的bin所在的路径；3.执行javac
配置环境变量：为了让java,javac这些可执行程序在任何路径下都可以被执行。
        1.添加一个变量：JAVA_HOME :jdk的安装地址
        2.在path中：添加%JAVA_HOME%\bin(可执行程序的路径)，%在win中代表取其地址    
           当执行java或javac这些可执行程序时，系统会去path中配置的路径下去找相应的程序。
编写java程序：d.java
编译程序：由于电脑只认识0,1  所以执行前要先进行编译，把java源代码转成电脑认识的 ---javac
 1.吧路径切换到源文件的位置；
 2.javac d.java 编译，编译完会生成和类名相同的.class文件(字节码文件)，有多少个类就生成多少个.class文件
执行程序 ：执行字节码文件，JVM负责 
    执行含有入口的类(字节码)。java Demo1

第二章：基本语法
2.1关键字
关键字：被java赋予了特殊含义的单词
2.2标识符
标识符：程序中需要自己起名字的   如：类名   由字母，0-9，_，$组成，不能以数字开头，不能和关键字同名，
类名：每个类名首字母必须大写
注释：// 单行注释 /*    */多行注释
缩进
常量：程序中用到的固定不变的数
机制转换：十进制，二进制，八进制，十六进制

 

最小单位是byte(字节)，如写4，写成00000100。

八进制：3位数的二进制转换为一位数，最大的数为7，说明3位数取值在0-7中，就是8进制。

 

System.out.println(14);
System.out.println(014); //八进制
System.out.println(0x14); //十六进制

原码，反码，补码：
        正数都是本身
        负数原码首位为1，反码是符号位不变，其余相反，补码就是反码加1。
 6                               -6
原码    00000110             10000110
反码    00000110        11111001
补码    00000110             11111010

一个字节表示的十进制数的范围(包括负数 )：1000 0000   在机器里和数学不一样，这里面都是0是最小的。首位仅代表符号位，与数学中无关。
故答案为  -128，127      

　　理解为：1111 1111 是负数，所以0111 1111 是最大的数，为127

　　　　　　1111 1111 是-127，因为第一个1是符号位，故可以再进位到首位，所以是-128

数据类型：决定变量占据多大的内存
 　　　　  分为两大类：基本数据类型和引用数据类型
 　　         基本数据类型有8种：整数类型：byte 字节类型  内存大小，一个字节   -128---127
                                                     　　          short 短整型，2个字节      -32768----32767
                                                  　　   　　   int   整形，4个字节   
                                              　　       　　   long  长整形，8个字节
                          　　          　　浮点型： float  单精度浮点型，4个字节，精确到7位
                              　　　                     double 双精度浮点型，8个字节，精确到16位
                                　　　　   布尔类型：boolean  只有两个数值  true和false  一个字节。
                                　　 　　  字符类型：char         两个字节  使用的是unicode编码表，单引号里面只能放一个字符
        　　 引用数据类型：字符串类型 String

 数据类型转换：数据类型是有级别高低的，从低到高：byte，sort，char>int>long>float>double
       自动类型转换(低级别到高级别)
       强制类型转换(高级别到低级别)
转义字符(就是改变它的意思)：通过反斜杠改变后面所跟字符的含义

class Demo2
{
    public static void main(String args[]){
        /*    
            数据类型：决定变量占据多大的内存
            分为两大类：基本数据类型和引用数据类型
            基本数据类型有8种：整数类型：字节类型：byte  内存大小，一个字节   -128---127
                                                   short 短整型，2个字节      -32768----32767
                                                   int   整形，4个字节          
                                                   long     长整形，8个字节
                                浮点型：float  单精度浮点型，4个字节，精确到7位
                                        double 双精度浮点型，8个字节，精确到16位
                                布尔类型：boolean  只有两个数值  true和false  一个字节。
                                字符类型：char    两个字节  使用的是unicode编码表，单引号里面只能放一个字符
            字符串类型   String     
                                        
        */
        float f=66.6f;    //一个小数默认是double类型，所以在后面加f可表示float类型
        boolean b=false;
        char c='m';
        System.out.println(c);
        char c1=97;
        System.out.println(c1);
        
    //    char c2='97';
    //    System.out.println(c2);
        char c3='你';
        System.out.println(c3);    
    }

}
class A
{
    public static void main(String args[]){
        byte b=45;
        short s=56;
        int a=88;
        double d=8900;
        //自动类型转换
        double sum=b+s+a+d;//从低级别到高级别会自动转换
        System.out.println(sum);
        //自动类型转换
        byte m=127;//java中一个整数默认看成double类型
        System.out.println(m);

        //强制类型转换:从高级别到低级别
        m=(byte)(m+10);  //赋值                                
        System.out.println(m);    //答案为-119
        
        int g='A';//自动类型转换
        char ch=97; //砍掉前两个字节

    }
}
class B
{
    public static void main(String args[]){
        //转移字符：通过反斜杠改变后面所跟字符的含义
        System.out.println("h\'ello\" wor\\ld! 呵呵 \n 哈哈哈");
        System.out.println("-----\t -----");

    }
}

classA的m输出过程

class B的运行结果为：

day2

   ·java中的运算符：

          算术运算符： + - * / % ++ --
          赋值运算符：=  +=  -=  *=  /=  %=（复合赋值运算符）
 例如：short s=5;
           s=(short)(s+5); //进行强制类型转换
           s+=5; //使用复合赋值运算符
           //s=s+5   由于左边的s是short 类型，右边的5是int类型，自动类型转换会使数据丢失。
          关系运算符：>  >=  <=  ==  !=
          逻辑运算符：&&(与)    ||(或)   内部执行效率更快
  &   | 
    !(非)
  &&:短路与：math>90 && eng>90:左边的表达式值为false，右边的表达式就不计算了，因为结果肯定为false
  ||:短路或：math>90 || eng>90:左边的表达式值为true，右边的表达式就不计算了，因为结果肯定为true。
  &：逻辑与：左边的表达式值为false，右边的表达式仍然计算
  |: 逻辑或：左边的表达式值为true，右边的表达式仍然计算
           位运算符：二进制位    &(按位与，对应位上全是1，才是1)  |(按位或，对应位上只要有1，就是1) 
              ^(按位异或，异即对应位上不同为1，相同为0，一个数异或另一个数两次，还是原数，可以用来实现加密) 
              ~(按位取反，原数取反的话，得到的数就是-(原数-1)可以很快取到反码)
              <<左移（低位补0）        >>右移(高位是0就补0，高位是1就补1)       >>>(无符号右移，高位只补0)
                左移就是 原数*2的几次方     右移要是正数，就是原数/2的几次方要是负数，就要先看补码，再回到源码
               <<< （当不想改变数本身的二进制位时，使用无符号右移，用于进制转换移位时防止符号位出错）。
表达式：由运算符和数据组合在一起叫表达式
表达式是有值的，

class  ZQF
{
 public static void main(String[] args) 
 {
  //+:连接符号
  int a=5,b=6;
  //字符串和任何类型的数据相连接，最后都是字符串
  System.out.println("hehe"+a+b); //hehe56
  System.out.println("a="+a+",b="+b);
  System.out.println(a+","+b);
  System.out.println(5/2.0); //结果为2.5
  System.out.println(5%2.0);  //结果为1.0
  System.out.println(-5%2); //-1 ，结果的正负由被除数决定，和除数无关
  System.out.println(-5%-2); //-1
  int num=3456; //求这个整数每一位上的数的和
  int ge =num%10;
  int shi=num/10%10;
  int bai=num/100%10;
  int qian=num/1000;
  int m=5,n;
  n=m++; //先取m的值，取到的值赋给左边的N,然后m再自身加1
  n=++m; //m先自身加1，然后再赋给左边的变量n,++在后边，先取值，再赋值给左边
  System.out.pritntln("m="+m+",n="+n);
  
  int a=9;//声明变量
  short s=5;
  //s=(short)(s+5);
  s+=5; //s=s+5
  //关系运算符
  int x=55,y=66;
  //x>y :关系表达式 表达式：运算符和数据组合在一起组成了表达式
  System.out.println(x<y);  //结果只有两种可能，关系成立--true，关系不成立--false
  System.out.println(x=99);  //赋值表达式
  System.out.println(x!=y);
  
  //逻辑运算符： &&   || !
  int math=90,eng=60;
  math>90 && eng>90; //表达式
  System.out.println(math>90 && eng>90); //表达式
  //true && false=false
  //true && true=true
  System.out.println(math>90 || eng>90); 
  System.out.println(!true);
  System.out.println(!(math==67));

  /*
   &&:短路与：math>90 && eng>90:左边的表达式值为false，右边的表达式就不计算了，因为结果肯定为false
   ||:短路或：math>90 || eng>90:左边的表达式值为true，右边的表达式就不计算了，因为结果肯定为true。
   &：逻辑与：左边的表达式值为false，右边的表达式仍然计算
   |: 逻辑或：左边的表达式值为true，右边的表达式仍然计算
  */
  System.out.println(~8);//-9

 } 
}

public class Test{
 public static void main(String args[]){
  System.out.println(~6);
  题目：将一个十进制数转成十六进制数（使用位运算符）
  int num=60;
  int n1=num&15;
  int n2=num>>>4;
  System.out.println(""+n2+(char)(n1-10+'a')); //把高级别的转成低级别的，n1-10为Int类型，比char类型大，2加‘a'为99，转成char类型为'c'


  //对两个整数变量的值进行交换
   //第一种使用加减
  int a=5,b=6;
  a=a+b;  //a+b的值可能溢出
  b=a-b;
  a=a-b;
  System.out.println("a="+a+",b="+b);
   //第二种使用异或
  a=a^b;
  b=a^b; //a^b^b   即a
  a=a^b; //a^a^b   即b
  System.out.println("a="+a+",b="+b);
   //第三种使用第三个变量
   int c=0;
   c=a;
   a=b;
   b=c;
  System.out.println("a="+a+",b="+b);


  //三元运算符
  int x=3,y=6;
  int m;
  x>y?x:y  //先计算？号前面的表达式，如果表达式的值为true，取：号前边的值，否则取：后边的值
  m=a>b?a:b; //赋值是最后进行的
  System.out.println(m);

  //使用三元运算符，获取最大的整数
  int x=56,y=23,z=125;
  int a,max;
  a=x>y?x:y;
  max=a>z?a:z;
 }

   ·选择结构：if....else if...elseif...else...switch()   case

class D{
 public static void main(String args[]){
  int a=4;

  //取值，比case
  //直到遇到break或者右大括号
  //当所有都不匹配时，就会执行default。执行后还是要按照第二步走。

  switch(a) //switch:开关　　　　//支持byte char int short ,枚举，String
  {
   default:
    System.out.println("ok");
   case 1:
    System.out.println("1");//break
   case 2:
    System.out.println("2");//break
   case 3:
    System.out.println("3");break; //break可以拦截
  }

  int month=4;
  switch(month)
  {
   case 3:
   case 4:
   case 5:System.out.println("春季");break;
   case 6:
   case 7:
   case 8:System.out.println("夏季");break;
   case 9:
   case 10:
   case 11:System.out.println("秋季");break;
   case 12:
   case 1:
   case 2:System.out.println("冬季");break;
   default:
    System.out.println("无效月份");

 }  
 } 
}

   ·循环结构：

　　while(条件)     与   do....while...     （区别：do...while...至少能执行一次）        for循环

 1 class D{
 2  public static void main(String args[]){
 3   //while...    //先判断再执行11
 4   int i=9;
 5   while(i>=0){
 6    System.out.println("hello ");
 7    i--;
 8   }
 9   //do ...  while...//先执行再判断
10   int j=1;
11   do{
12    System.out.println("hello world");
13    j++;
14   }while(j<=5);
15  
16   //for循环  //先执行表达式1，再执行表达式2，如果表达式2成立，再执行表达式中的代码4
17      //然后执行表达式3，再执行表达式2，成立执行表达式2，反复直到表达式2不成立，则退出循环。
18   for(int j=1;j<=5;j++ )
19   {
20    System.out.println("--"); 
21   }
22   System.out.println(j); //找不到符号
23   //变量的作用域：从其定义的位置开始，到其所在的大括号结束。
24   //for循环结束，变量j同时释放内存，所以当循环中使用的变量在循环结束后不再使用适合使用for循环，否则适合使用while()或do{}while循环。
25  }
26 }

 

变量的作用域：从其定义的位置开始，到其所在的大括号结束。

 

 day3

   ·嵌套循环

class  A
{
    public static void main(String[] args) 
    {    
        /*
            嵌套循环： 外层循环控制行数，内层训话控制列数
            *****
            *****
            *****
            *****
            *****
        */
        for(int j=1;j<=5;j++){
        for(int i=1;i<=5;i++)
        System.out.println("*");
        }
        System.out.println();




        for(int i=1;i<=5;i++){
            for(int j=1;j<=1;j++){
                System.out.print("*");
            }
            System.out.println();
        }

        for(int i=1;i<5;i++){
            for(int j=1;j<=i;j++){
                System.out.print(j);
            }
            System.out.println();
        }

/*打印九九乘法表
1*1=1
1*2=2 2*2=4
1*3=3 2*3=6 3*3=9
1*4=4 2*4=8 3*4=12 4*4=16
*/
        for(int i=1;i<=9;i++){
            for(j=1;j<=i;j++){
                System.out.println(j+"*"+i+"="+j*i+" ");
            }
            System.out.println();

        }

/*打印一个实心菱形图案
        *
       *** 
      *****
     *******
      *****
       ***
        *
*/
        for(int i=1;i<=4;i++){
            //要先输出空格
            for(int j=1;j<=4-i;j++){
                System.out.print(" ");
            }
            //再输出*
            for(int j=1;j<=2*i-1;j++){
                System.out.println("*");
            }
            System.out.println();
        }
        for(int i=1;i<=3;i++){
            //要先输出空格 1 2 3
            for(int j=1;j<=i;j++){
                System.out.print(" ");
            }
            //再输出*
            for(int j=1;j<=7-2*i;j++){
                System.out.println("*");
            }
            System.out.println();
        }


/*
        *
       * *
      *   *
     *     *
      *   *
       * *
        *
*/
        for(int i=1;i<=4;i++){
            //要先输出空格
            for(int j=1;j<=4-i;j++){
                System.out.print(" ");
            }
            //再输出*
            for(int j=1;j<=2*i-1;j++){
                if(j==1||j==2*i-1)
                System.out.println("*");
                else
                    System.out.println(" ");
            }
            System.out.println();
        }
        for(int i=1;i<=3;i++){
            //要先输出空格 1 2 3
            for(int j=1;j<=i;j++){
                System.out.print(" ");
            }
            //再输出*
            for(int j=1;j<=7-2*i;j++){
                if(j==1||j==7-2*i)
                System.out.println("*");
                else 
                    System.out.print(" ");
            }
            System.out.println();
        }

    }
}

 

   ·break和continue

class B
{
    public static void main(String args[]){
        //循环中可以使用的语句： break：结束整个循环   continue:结束某一次循环
        for(int i=1;i<5;i++){
            if(i==3)
                break;        //默认第一条语句属于if的，
            System.out.println(i);    //这个是if下的第二条语句不属于if 结果为1,2
        }
        for(int i=1;i<5;i++){
            if(i==3){
                break;        //break后不能加任何代码
                System.out.println(i);    //程序报错，由于break已经结束，故不能有此行
            }
        }


        for(int i=1;i<5;i++){    
            for(int j=1;j<=5;j++){
                if(j==3){
                    break;    //结束的是内部的for,不会结束外面的for
                }
            }
            System.out.println(i);    //故输出1,2,3,4,5
        }


        m:for(int i=1;i<5;i++){
            n:for(int j=1;j<=5;j++){
                if(j==3){
                    break m;    //结束的是外循环
                }
            }
            System.out.println(i); //故无输出结果
        }



        for(int i=1;i<=5;i++){
            if(i==3){
                continue;//结束的是第三次的循环，也就是直接进入第四次循环，也就是去执行i++
            }
            System.out.print(i);    //1 2 4 5
        }

        for(int i=1;i<5;i++){    
            for(int j=1;j<=5;j++){
                if(j==3){
                    continue;    //结束的是内部的for,不会结束外面的for
                }
            }
            System.out.println(i);    //故输出1,2,3,4,5
        }

        for(int i=1;i<5;i++){
            for(int j=1;j<=5;j++){
                if(j==3){
                    System.out.println(i); System.out.println(j);//分别是i为1，2，3，4，5 ；j为3，3，3，3，3；  
                    continue ;    
                }
            }
        }

        for(int i=1;i<5;i++){
            if(i==3){
                continue;        //continue后不能加任何代码
                System.out.println(i);    //程序报错，由于break已经结束，故不能有此行
            }
        }
        

    }
}

 

import java.util*;
class  C
{
    public static void main(String[] args) 
    {
        //编写一个程序，最多接收10个数，求这些数的和
        //用户可以通过输入999来终止程序，并显示输入数的和
        int sum=0,num;
        Scanner sc=new Scanner(System.in);
        
        for(int i=1;i<=10;i++){
            System.out.println("输入一个数");
            num=sx.nextInt();
            if(num==999)
                break;
            sum=sum+num;
        }
        System.out.println("sum="+sum);//如果注释了14,15行，for一直循环，则此行不会执行，会在编译时报错
    }
}

    ·函数：

为什么用函数：避免代码重复出现，当一个相同功能被多次使用时，如果没有函数，每次都要写重复性的代码。
函数：具备特定功能的一段独立的代码段。什么时候用到这个功能，什么时候就调用
函数关键是实现功能，实现功能用到的数据以参数的形式来接收，如果功能最终得到的是一个数值，需要返回值。
函数的返回值类型就是使用return返回的数值的类型。

　　返回值类型  函数名（参数类型 参数1，参数类型 参数2....）{
 　　执行语句
 　　return 返回结果
　　}
　　注：void 代表无返回值，否则函数名前需加返回值类型

 

import java.util.Scanner;
class  D
{    
    //定义函数：具备特定动能的一段独立的代码段，什么时候用到这个功能，什么是时候去调用
    //对于函数来说，关键是实现功能，功能中用到的数据不是函数考虑的重点，重点是功能。
    public static int add(int a,int b){//形式参数：用参数来接收数据，被调用的
        int sum=a+b;
        return sum;    //把值返回到函数调用的位置
        System.out.println("sum="+sum);        //由于上面已经return了所以这行会报错，运行不到此行
    }
    
    public static int add(int a,int b){//形式参数：用参数来接收数据，被调用的
        int sum=a+b;
        return sum;    //把值返回到函数调用的位置
        System.out.println("sum="+sum);
    }

    public static void main(String[] args) //主函数
    {    
        int n=add(6,8);//实参，函数调用，实参和形参要在类型，顺序，个数上保持一致      n=sum,
        if(n>20)
            System.out.println("n="+n);
        System.out.println("okok");
    }
}
//每次用到相同的动能都要写重复的代码，冗余。
//函数是用来解决一个功能被重复使用的功能的。

class E 
{
    public static void main(String[] args) 
    {
        boolean b= isEqual(4,5);
        System.out.println(b);
        int max=getMax(34,56);
        System.out.println(max);

        juXing(5,5);
        jiuJiu();e
    }

    //自己定义函数：确定有没有参数，确定有没有返回值
    
    //判断两个整数是否相等
    //参数：两个整数
    //返回值：boolean

    public static boolean isEqual(int a,int b){
        return a==b;    //返回到函数调用的位置

    }
    //求两个整数中的最大值
    //参数：两个整数
    //返回值：int
    public static int getMax(int a,int b){
        return a>b?a:b;
    }

    //用*号打印一个矩形
    //参数：行数，列数
    //返回值：无返回值
    public static void juXing(int rows,int col){
        for(int i=1;i<=rows;i++){
            for(int j=1;j<=col;j++){
                System.out.print("*");
            }
            System.out.println();
        }
    }
    
    //打印99乘法表
    //参数：无
    //返回值：无
    public static void jiuJiu(){
        for(int i=1;i<=9;i++){
            for(int j=1;j<=i;j++){
                System.out.print(j+"*"+i+"="+"j*i"+\t);
            }
                System.out.println();
        }
    }
}

   ·函数内存的分配

 

    ·函数的重载

class E 
{
    public static void main(String[] args) 
    {
        boolean b= isEqual(4,5);
        System.out.println(b);
        int max=getMax(34,56);
        System.out.println(max);

        juXing(5,5);
        jiuJiu();e
    }

    //自己定义函数：确定有没有参数，确定有没有返回值
    
    //判断两个整数是否相等
    //参数：两个整数
    //返回值：boolean

    public static boolean isEqual(int a,int b){
        return a==b;    //返回到函数调用的位置

    }
    //求两个整数中的最大值
    //参数：两个整数
    //返回值：int
    public static int getMax(int a,int b){
        return a>b?a:b;
    }

    //用*号打印一个矩形
    //参数：行数，列数
    //返回值：无返回值
    public static void juXing(int rows,int col){
        for(int i=1;i<=rows;i++){
            for(int j=1;j<=col;j++){
                System.out.print("*");
            }
            System.out.println();
        }
    }
    
    //打印99乘法表
    //参数：无
    //返回值：无
    public static void jiuJiu(){
        for(int i=1;i<=9;i++){
            for(int j=1;j<=i;j++){
                System.out.print(j+"*"+i+"="+"j*i"+\t);
            }
                System.out.println();
        }
    }
}

    ·数组，局部变量，栈，堆

局部变量：在函数或语句中(如：for语句，for(int i=1;i<5;i++)定义的变量
局部变量的特点：作用域结束后，立刻释放内存。
当函数被调用时，函数入栈，函数内定义的变量在栈中开辟内存，当函数内的代码全部执行完，函数出栈，也就是释放内存

数组：数组的作用：解决存储多个数据的问题
int [] arr=new int[5]是一个局部变量，存的是一个地址值，引用类型的变量， 是数组的一个引用，
int a ; //a存的是一个整数，基本数据类型的变量

class  G
{
    public static void main(String[] args) 
    {
        //数组的作用：解决的是存储多个数据的问题,数组属于引用数据类型
        //定义一个可以存储5个整数的数组
        //new int[5];    //开辟了5个int类型的内存空间   
        //为了方便使用数组，需要定义一个名字
        //arr=new int[500];

        //指定arr代表的数组的类型 
        int[] arr=new int[500];    //int a;数组占据的内存是连续的
        arr[0]=12;
        System.out.println(arr[0]);

        /*
            jvm把内存分为5块：栈，堆，方法区，本地方法区，寄存器
            栈：局部变量进栈，在函数或语句中定义的变量属于局部变量，如for语句，for(int i=1;i<5;I++)
                特点：作用域结束立刻释放内存
            堆：引用数据类型属于堆
                特点：有默认值为0；
        */
    }
}

    ·数组内存的分配：

 

 

 

 

 

 day4

   ·堆和栈对比

1.堆中有默认值，栈中没有默认值
2.堆中的垃圾需要垃圾回收线程回收，也就是说当出现垃圾时，不一定会立刻被回收
3.栈是使用完立刻释放内存
4.局部变量进栈，在方法，语句中定义的变量
5.对象，数组进堆（特点：都是可以存储多个数据的）

栈和堆的对比：
栈：局部变量进栈，在函数，语句定义的变量
      局部变量的作用域结束，立刻释放内存
      进栈的局部变量没有默认值

堆：对象，数组在堆中开辟内存，堆中有默认值，堆中的一旦成为垃圾，需要等待垃圾回收线程回收，不会立刻释放内存。

 

   ·引用类型的内存的特点

int[] arr=new int[5];
arr 是一个引用类型的变量
new int[5]:在堆中开辟内存
arr存的是数组在堆中的首地址，因为arr存储了数组的地址，所以可以通过arr来操作数组
arr[0]=66；先从arr中取出地址值，去堆中找到数组，然后给数组下标为0的赋值为66。
arr=new int[3]; arr又创建了一个新的数组，把该数组的地址存储在arr中，arr不在指向之前的数组，因为arr是一个变量，它的值可以改变

   ·数组：

　　  解决了存储多个数据的问题，属于引用数据类型。
         数组的内存是连续的，通过下标的方式来区分，下标固定从0开始。
         int[] arr=new int[5];
         for(int i=0;i<arr.length;i++){
 System.out.println(arr[i]); 
         }

 

   ·数组的初始化及异常

import java.util.*;
class C 
{
    public static void main(String[] args) 
    {
        int[] arr=new int[5];//0-4
        //System.out.println(arr[5]);//ArrayIndexOutOfBoundsException: 5 数组下标越界
        //arr =null;    //arr不指向任何数组
        //System.out.println(arr[0]);//NullPointerException    空指针
        arr[0]=12;
        arr[1]=12;
        arr[2]=12;
        arr[3]=12;
        arr[4]=12;
        for(int i=0;i<5;i++){
            System.out.println("请输入第"+(i+1)+"个数");
            arr[i]=sc.nextInt();

            arr[i]=12;
        }
    //    for(int i=0;i<5;i++){
    //        System.out.println(arr[i]);
    //    }
        //arr.length得到的是数组的长度
        for(int i=0;i<arr.length;i++){
            System.out.println(arr[i]);
        }
    }
}
 
 class Demo1
 {
     public static void main(String arg[]){
        //数组的初始化
        int[] arr=new int[] {12,34,56,6};    //数组的长度是数值的个数
        for(int i=0;i<arr.length;i++){
            System.out.println(arr[i]);

        int[] b={1,2,3,4,5,6}    
        for(int i=0;i<b.length;i++){
            System.out.println(b[i]);
        }
     }
 }

 

//功能：求数组中的最大值
    //参数：数组
    //返回值：最大值
    public static int getMax(int[] arr){
        int max=arr[0];
        for(int i=1;i<arr.length;i++){
            if(arr[i]>max){
                max=arr[i];
            }
        }
        return max;
    }

   ·数组的选择排序与冒泡排序

 

 

 

 

 

  

//选择排序与冒泡排序
class E 
{
    public static void main(String[] args) 
    {
        int [] arr={23,45,12,6,78,4};

        selectSort(arr);
        for(int i=0;i<arr.length;i++)
        System.out.print(arr[i]+" ");
    
        System.out.println("------------------");
    
        bubbleSort(arr);
        for(int i=0;i<arr.length;i++)
        System.out.print(arr[i]+" ");
        
    }
    //选择排序
    //参数：数组
    //返回值：无
    public static void selectSort(int [] arr){
        for(int i=0;i<arr.length-1;i++){
            for(int j=i+1;j<arr.length;j++){
                if(arr[j]<arr[i]){
                    huan(arr,j,i);
                }
            }
        }
    }
    public static void huan(int[] arr,int m,int n)
    {
        int c;
        c=arr[m];
        arr[m]=arr[n];
        arr[n]=c;
    }
    
    //冒泡排序
    public static void bubbleSort(int [] arr){
        for(int i=0;i<arr.length-1;i++){
            for(int j=0;j<arr.length-i-1;j++){
            if(arr[j+1]<arr[j]){
                huan (arr,j+1,j);
                }
            }
        }    
    }
}

 

 

   ·数组的查找和二分查找

//查找：一个数在数组中第一次出现的下标，没有返回-1
class F 
{
    public static void main(String[] args) 
    {
        int[] arr={23,12,5,44,77,66,99};
        int key=44;
        int index=find(arr,key);
        System.out.println("index="+index);


    /*    int i=0;
        for(;i<arr.length;i++){
            if(arr[i]==44){
                System.out.println(i);//找到第一个相同的就结束循环，
                break;
            }
        }
        if(i==arr.length){
            System.out.println(-1);
        }

    */
    }

    public static int find(int[] arr,int key){
        for(int i=0;i<arr.length;i++){
            if(arr[i]==key){
                return i;    //返回函数调用的位置
            }
            return -1;        //返回函数调用的位置
        }
    }
}

//二分法查找：前提条件数组必须是有序的
class G
{
    public static void main(String args[]){
        int[] arr={12,34,45,56,67,78,89};
        int index=halfSearch(arr,89);
        System.out.println("index="+index);
    }
        
    public static int halfSearch(int [] arr,int key){
        int min=0,max=arr.length-1,mid;
        while(min<=max){
            mid=(min+max)/2;
            if(key>arr[mid]){
                min=mid+1;
            }else if(key<arr[mid]){
                max=mid-1;
            }else
                return mid;
        }
        return -1;
    }
}

 day5

   ·判断回文数和质数

class Demo1 
{
    public static void main(String[] args) 
    {
        int  a;  //基本类型的变量
        int[] arr=null;//引用类型的变量
        arr=new int[5];
        arr[0]=77;
        int a;
        int[] arr=null;//  int[] 是一种引用数据类型
        Scanner sc = new Scanner();
    }

    //判断一个数是不是质数  （只能被1和它自己整除的数）
    //参数：一个数
    //返回值：boolean

    public static boolean isZhiShu(int num)
    {
         for(int i=2;i<num/2;i++)
         {
             if(num%i==0)
                return false;
         }

         return true;
    }

    //判断一个数是不是回文  121
    //参数：一个数
    //返回值:boolean
    public static boolean isHuiWen(int num)  //121
    {
         int sum=0,n;
         n=num;
         while(num!=0){
             sum=sum*10+num%10;//121
             num=num/10;
         }

         if(sum==n)
             return true;
         else
             return false;
    }
}

   ·十进制转为二，八，十六进制

class Demo3 
{
    public static void main(String[] args) 
    {
        toHex(60);
        toOctal(60);
        toBinary(60);
    }

    //十进制转十六进制
    //参数：十进制数
    //返回值：无

    public static void toShiLiu(int num)
    {
        int[] arr=new int[8];
        int index=arr.length;//8

        while(num!=0)
        {
            arr[--index]=num&15;
            num=num>>>4;
        }

        //System.out.println("index="+index);

        for(;index<arr.length;index++)
        {
            if(arr[index]>9)
                System.out.print((char)(arr[index]-10+'a'));
            else
                System.out.print(arr[index]);
        }
    }

    //十进制转十六进制:查表法
    public static void toShiLiu2(int num)
    {
        char[] ch={'0','1','2','3','4','5','6','7','8','9','a','b','c','d','e','f'};
        char[] arr=new char[8];
        int index=arr.length;

        while(num!=0)
        {
            int x=num&15;  // 13
            arr[--index]=ch[x];
            num=num>>>4;
        }

         for(;index<arr.length;index++)
        {
            System.out.print(arr[index]);
        }
    
    }

    //十进制转八进制
    public static void toBa(int num)
    {
        char[] ch={'0','1','2','3','4','5','6','7'};
        char[] arr=new char[11];
        int index=arr.length;

        while(num!=0)
        {
            int x=num&7;  // 13
            arr[--index]=ch[x];
            num=num>>>3;
        }

         for(;index<arr.length;index++)
        {
            System.out.print(arr[index]);
        }
    }
    //十进制转2进制
    public static void toEr(int num)
    {
        char[] ch={'0','1'};
        char[] arr=new char[32];
        int index=arr.length;

        while(num!=0)
        {
            int x=num&1; 
            arr[--index]=ch[x];
            num=num>>>1;
        }

         for(;index<arr.length;index++)
        {
            System.out.print(arr[index]);
        }
    }

    public static void toAny(int num,int base,int offset)
    {
        char[] ch={'0','1','2','3','4','5','6','7','8','9','a','b','c','d','e','f'};
        char[] arr=new char[32];
        int index=arr.length;

        while(num!=0)
        {
            int x=num&base;
            arr[--index]=ch[x];
            num=num>>>offset;
        }

        for(;index<arr.length;index++)
        {
            System.out.print(arr[index]);
        }
    }
    public static void toHex(int num)
    {
        toAny(num,15,4);
    }
    public static void toOctal(int num)
    {
        toAny(num,7,3);
    }
    public static void toBinary(int num)
    {
        toAny(num,1,1);
    }

}

一维数组：
 int[ ] arr=new int[5];  
 求最值

 排序:Arrays.sort();

 查找：二分法查找 int key;   Arrays.binarySearch(arr,key);

 进制转换:Integer.toHexString()    Integer.toOctalString()   Integer.toBinaryString()

 

   ·数组去重

1：创建两个一维数组，对两个有序的数组进行合并，并将重复的数字去掉
class T1 
{
    public static void main(String[] args) {
        int [] num1=new int[]{1,4,5,6,7};
        int [] num2=new int[]{3,5,6,8};
        hebing(num1, num2);
    }
    private static void hebing(int [] num1,int [] num2){
        int[] result=new int[num1.length+num2.length];

        int i=0,j=0,k=0;//定义三个变量。i  j  k分别控制num1 num2  result三个数组的下标

        while(i<num1.length && j< num2.length){//两个数组都不为空的时候
            if(num1[i]<num2[j]){//若num1的元素小，加入result
                result[k]=num1[i];
                i++;//num1的下标后移
                k++;//result的下标后移
            }else if(num1[i]==num2[j]){//若二者相等 这一步就是去重复。
                result[k]=num1[i];//这里两个数组的元素把哪个加入result都行
                k++;//result下标后移
                i++;//这里要注意的是  两个重复了，去重之后，两个数组的下标都要后移
                j++;
            }else {
                result[k]=num2[j];//若num2的元素小，加入result
                k++;
                j++;
            }    
        }
 
        //下面是当其中一个数组元素全部添加到result了，另一个还没添加完  继续添加。
        while(i<num1.length){//
            result[k]=num1[i];
            i++;
            k++;
        }
        while(j<num2.length){
            result[k]=num2[j];
            j++;
            k++;
        }
        for (int i=0;i<result.length;i++) 
        {
            System.out.println(result[i]);
        }
    }

}

   ·生成范围内的验证码

5.生成4位网站验证码(要求用数组)
  1 不能重复
  2 只能是数字和大小写字符, 但是不能包含1,0,o,O,l,L,Z,2,9,g

 import java.util.Random;
class T2 
{
    public static void main(String[] args) 
    {
       char[] arr={'3','4','5','6','7','8','a','b','c','d','e','f','h','i','j','k','m','n','p','q','r','s','t','u','v','w','x','y','z','A','B','C','D','E','F',
              'G','H','I','J','K','M','N','P','Q','R','S','T','U','V','W','X','Y'};

                char[] r=new char[4];//存放验证码的数组
        int count=0,num,index=0;
        Random random = new Random();
        boolean flag=true;
        while(count!=4)
        {
            num=random.nextInt(arr.length);//生成随机的下标
            System.out.println(num);
            flag=true;
            for(int i=0;i<4;i++)
            {
               if(r[i]==arr[num])
                {
                   flag=false;
                   break;
                }
                
            }
            if(flag)
            {
                r[index++]=arr[num];
                count++;
            }
        }
        System.out.println();
        for(int i=0;i<4;i++)
           System.out.print(r[i]);
    }
}

 

   ·二维数组：    内存

 int[ ][ ] arr=new int[5][ ];

 

 

   

   ·类和对象

把对象装进冰箱
面向过程：打开冰箱，装大象，关闭冰箱
面向对象：冰箱.打开（）
类是对对象的描述，属于概念性的东西，
对象：使用new创建的对象才是实实在在存在的实体。

描述对象的类-------》使用类(字节码)创建的对象--------》对象具备了类中定义的属性和方法

class Person
{
    String name;//属性用变量表示
    int num;
    int age;
    public void eat(){    //行为用函数表示
        System.out.println("吃");
    }
}

class Demo5
{
    public static void main(String[] args){
        Car che=new Car();    //创建对象
        Person ren=new Person();//对象具备Person类中定义的属性和行为
        ren.name="李四";
        ren.age=20;
        System.out.println(ren.name+"   "+ren.age);
        ren.eat();

    }
}
/*jvm先执行main方法，main方法属于Demo5.class字节码，所以先加载Demo5.class到方法区
    （原则：用到谁加载谁）
    
  创建Person的对象使用的是Person.class，所以先加载Person.class到方法区
  当常见对象时，在堆中为属性开辟内存
  eat()方法，使用时直接进栈
  类加载器把字节码加载到方法区
    */

 

 

   ·成员变量和局部变量的对比：

1.成员变量 有默认值
   局部变量没有默认值
2.成员变量是随着对象的创建在堆中开辟内存
   局部变量是随着其所在函数被调用在栈中开辟内存
3.成员变量是随着对象被垃圾回收才释放内存
   局部变量作用域结束立刻释放内存。
4.成员变量的作用范围是整个类
   局部变量的作用域是其所在的大括号

   ·面向对象的三大特征-封装

 

//封装：只对外界提供有用的属性和行为
class Person{
     String name;  
     private int age;
     
     public void setAge(int nianling){
        if(nianling<0 || nianling>120)
            System.out.println("年龄不合法");
        else
            age=nianling;
     }
     public int getAge(){
        return age;
     }
    public void eat(){
       System.out.println(age+"吃");
    }
}
class Demo9 {
    public static void main(String[] args) {
        Person ren = new Person();
        ren.setAge(20);
        int age = ren.getAge();
        System.out.println(age);
       
        //ren.age=-200; 报错        
    }
}

    ·构造方法

/*
构造方法： 只能用来创建对象的，系统会自动在类中加入一个默认的构造方法 类名(){}
            也可以自己定义构造方法，自己一旦写了构造方法，系统就不会再加入默认的构造方法
            构造方法是必须存在的
            构造方法可以有多个

特点：
   方法名和类名相同
   没有返回值类型

*/
class Person{
     String name;  
     private int age;

     Person(){}//创建对象时使用的方法

     Person(String mingzi,int nianling)//创建对象时使用的方法
     {
        name=mingzi;
        age=nianling;
     }

     public void setAge(int nianling){
         age=nianling;
     }
     public int getAge(){
         return age;
     }
}
class Demo10 
{
    public static void main(String[] args) {
        Person ren = new Person();//  Person():构造函数，
        Person ren2 = new Person("赵四",20);//创建对象的同时给属性赋值
        ren2.setAge(21);
        int a = ren2.getAge();
        System.out.println(a);  
    }
}

day6

   ·用数组打印杨辉三角

 杨辉三角

1
1  1
1  2  1
1  3  3  1
1  4  6  4   1
1  5  10 10  5  1
。。。。。。。。。。。

class Demo1 
{
    public static void main(String[] args) 
    {
        int[][] arr=new int[10][];
        arr[0]=new int[]{1};
        for(int i=1;i<10;i++){
            arr[i]=new int[i+1];
            for(int j=0;j<i+1;j++){
                if(j==0||j==i)
                    arr[i][j]=1;
                else
                    arr[i][j]=arr[i-1][j]+arr[i-1][j-1];
            }
        }
        for(int i=0;i<arr.length;i++){
          for(int j=0;j<arr[i].length;j++)
              System.out.print(arr[i][j]+"\t");
           System.out.println();
        }
    }
}

把一个数插入到数组, 第一个参数是被拷贝的数组，第二个参数是新数组的长度：

 

class Demo2 
{
    public static void main(String[] args) {
        //向一个有序的整型数组中插入一个数，插入后该数组还是有序的(二分法)
        int[] arr={12,34,56,67,78,89,99};
        int key=600;

        int index = halfSearch(arr,key);
        System.out.println("index="+index);
        index=-(index+1);
        //把这个数插入到数组, 第一个参数是被拷贝的数组，第二个参数是新数组的长度
        //返回一个新的数组
        
        int[] b=new int[arr.length+1];
        for(int i=0;i<arr.length;i++){
           b[i]=arr[i];
        }
        
        for(int i=arr.length-1;i>=index;i--){
            b[i+1]=b[i];
        }
        b[index]=key;

        for(int i=0;i<b.length;i++){
           System.out.print(b[i]+" ");
        }

    }
        //查找一个数在数组中的位置，并返回下标，
     public static int halfSearch(int[] arr,int key){
         int min=0,max=arr.length-1,mid;
         while(min<=max){
             mid=(min+max)>>1;
             if(key>arr[mid])
                 min=mid+1;
             else if(key<arr[mid])
                 max=mid-1;
             else
                return mid;//如果数存在，返回mid即下标
         }
         return -min-1;//不存在返回-min-1;
     }
}

 

   ·this

this:是一个引用，总是指向当前被使用的对象
构造函数之间的调用： this()；必须写在构造函数代码块的第一行 
this 在函数中，函数栈内存里，指向堆中的对象里的属性，所以this.变量 后面指的是成员变量，可以表示当前的；

Person(String name,int get)   //局部变量和成员变量同名时，使用的是局部变量，可以使用this来用成员变量

 

//this是一个引用，总是指向当前被使用的对象
class Person
{
     String name;  //成员变量的作用域是整个类
     int age;

     Person(){}

     Person(String name,int age){//局部变量和成员变量同名时，使用的是局部变量
     
        this.name=name;
        this.age=age;
     }

     //判断两个人是不是同龄人
     //参数：Person
     //返回值:boolean
     public boolean isAgeEqual(Person person){
          return age==person.age;
     }


     public void show(){
        System.out.println(this);
     }
}
class Demo4 
{
    public static void main(String[] args) {
        Person  ren = new Person("张三",25);//this指向这个对象

        Person  ren2= new Person("李四",25);//this指向这个对象

        boolean boo=ren.isAgeEqual(ren2);//this 指向 张三

        System.out.println(boo);

        //System.out.println(ren);
        //ren.show();
        //System.out.println(ren.name+","+ren.age);

        

    }
}

 

 

 

   ·static:静态：

　　   只能修饰类中的成员
         被static修饰的成员变量的特点：
         1.随着所属类(字节码)加载到方法区的同时，就在方法区内静态区中开辟内存
         2.被static修饰的成员变量(局部变量不能被static修饰)是类所有的对象共享的。
         3.可以直接通过类名访问
什么情况下可以把成员变量修饰为static：当成员变量是类的所有对象共享的变量。

静态的优先于非静态的开辟内存
非静态的成员变量是在创建对象是才开辟内存的，所有非静态的只能使用对象来访问
        

   ·静态成员变量与非静态成员变量对比：

   1.访问方式   静态成员变量既可以通过对象访问，也可以通过类名直接访问
      非静态成员变量只能使用对象访问
   2.存储数据   静态成员变量 存储的是所属类的所有对象共享的数据
      非静态成员变量  存储的是每个对象特有的数据
   3.存储位置   静态成员变量 随着类的加载在方法区的静态区开辟内存
      非静态成员变量 创建对象时在堆中开辟内存
   4.生命周期（从在内存中出现到从内存中消失）
      静态成员变量   随着类的加载在方法区的静态区开辟内存，程序退出时才释放内存   
      非静态成员变量   是创建对象时在堆中开辟内存，当所属对象成为垃圾时等待垃圾回收线程回收

静态的缺点：占用内存时间长

静态的方法只能使用静态的方法或变量
非静态的方法什么都可以用

 

class Student 
{
    String name;  //实例变量
    static String country="CN"; //类变量

    public void show()  //实例方法:只能使用对象访问
    {
       System.out.println(country+","+name);
    }

    public static void fun()//类方法 Student.fun()  
    {
       System.out.println(country);//无法从静态上下文中引用非静态 变量 name
    }
}
class Demo6 
{
    public static void main(String[] args) 
    {
        Student stu = new Student();
        stu.show();

        Student.fun();

        //System.out.println(Student.country);//随着所属类的加载在方法区的静态区中开辟内存
        //System.out.println(Student.name);
        //System.out.println(stu.country);

        //stu.country="USA";
        //Student stu2 = new Student();
        //System.out.println(stu2.country);
        
    }
}

   ·解析main()函数

public:说明是公共的
static:说明是静态的，随着类的加载进入静态区，可以直接通过类来调用
void:说明没有返回值
String[] args:参数是字符串数组 

class Test
{
    public static void main(String[] args){
       String[] arr={"haha","hehe","xixi"};
       Demo7.main(arr);
    }
}
class Demo7 
{
    public  static void main(String[] args){ //java Demo7 hello hehe haha xixi   命令行参数
        System.out.println(args.length);
        //for(int i=0;i<args.length;i++)
            //System.out.println(args[i]);
        Demo7 d = new Demo7();
        d.main(77);
    }
    public void main(int a){ //非静态方法，通过对象访问
       System.out.println(a);
    }
}

什么情况下成员变量可以被static修饰：
 　　当成员变量的值被所属类的所有对象共享时
什么情况下方法可以被static修饰：
 　　当该方法没有用到所属类中的非静态成员

class Person{
    int age;
    Person(int age){
       this.age=age;
    }
    public static void isEqual(Person person){
         System.out.println(person.age);
    }
}
class Demo8 
{
    public static void main(String[] args) {
        Person ren = new Person(20);
        Person.isEqual(ren);
    }
}

静态的应用：工具类（此代码省略）

   ·静态代码块：

static{...} 随着类(字节码)的加载而执行，只执行一次，优于main函数的执行
 把程序中初始化功能通常写在静态代码块中。

class Test
{
    static int num=10;
    static{
       System.out.println("C");
    }
    public static void show(){
        System.out.println(num);
    }
}
class Demo10 
{
    static{
       System.out.println("A");
    }

    public static void main(String[] args) {
        //Test t=new Test();
        //Test.show();//加载Test.class
        Test t=null;
    }
    static{
       System.out.println("B");
    }
}

   ·构造代码块：{...}

对象一创建就执行，优先于构造函数
 所有对象共性的功能可以写在构造代码块中。

/*
构造代码块：对象一创建就执行，优先于构造函数执行

所有对象共性的功能可以写在构造代码块中
*/
class Person
{
    String name;

    {                                    //构造代码块
       System.out.println("呵呵");
    }

    Person(String name)
    {
       this.name=name;
       System.out.println(name);
    }
}
class Demo11 
{
    public static void main(String[] args) {
        new Person("李四");

        new Person("张三");
    }
}

 day7

class Point
{
    private int x;
    private int y;
    Point(){}
    Point(int x,int y){
       this.x=x;
       this.y=y;
    }
    public void movePoint(int dx,int dy){
        x=dx;
        y=dy;
    }
    public void setX(int x){
       this.x=x;
    }
    public void setY(int y){
       this.y=y;
    }
    public int getX(){
       return x;
    }
    public int getY(){
       return y;
    }
}
class Test2 
{
    public static void main(String[] args) {
        /*
        定义一个点类Point,包含2个成员变量x,y,分别表示x和y坐标，创建两个构造方法Point()和Point(int x,int y),
        创建一个方法movePoint(int dx,int dy)实现点的位置的移动，在main方法中创建两个Point对象p1,p2，分别调用movePoint方法后，
        显示p1和p2的坐标
        */
        Point p1=new Point(5,8);
        Point p2=new Point(6,10);
        p1.movePoint(6,9);
        p2.movePoint(8,8);
        System.out.println("p1的坐标:x="+p1.getX()+",y="+p1.getY());
        System.out.println("p2的坐标:x="+p2.getX()+",y="+p2.getY());
    }
}

class Test4 {
    public static void main(String[] args) {
        /*
          某个公司采用公用电话传递数据，数据是四位的整数，在传递过程中是加密的，加密规则如下：
          每位数字都加上5,然后用和除以10的余数代替该数字，再将第一位和第四位交换，第二位和第三位交换。
        */
        int num=6789,c;
        int[] arr=new int[4];
        int index=arr.length;
        while(num!=0){
            arr[--index]=num%10;
            num=num/10;
        }
        for(;index<arr.length;index++){
            arr[index]=(arr[index]+5)%10;
        }
        for(int i=0,j=arr.length-1;i<j;i++,j--){
             c=arr[i];
             arr[i]=arr[j];
             arr[j]=c;
        }
        for(int i=0;i<arr.length;i++)
            System.out.print(arr[i]+" ");
    }
}

   ·对象初始化的过程

//对象的初始化过程：
/*
1:因为对象的创建是使用字节码，所以先加载字节码到方法区
2：如果有静态代码块执行静态代码块
3：在堆中开辟内存
4：给属性赋默认值
5：如果有初始值再赋初始值
6：执行构造代码块
7：执行构造函数
8：把对象在堆中的地址赋给在栈中的变量
*/
class Person{
    private String name="xiaohong";
    private int age=23;
    private static String country="CN";{
        System.out.println(name+"  "+age);
    }
    public Person(String name,int age){
        this.name = name;
        this.age = age;
    }
    public void setName(String name){
       this.name = name;
    }
    public String getName(){
        return name;
    }
}
class  Demo1{
    public static void main(String[] args) {
        Person p = new Person("小白",20);
        //p.setName("小黑");
    }
}

 

 

    ·设计模式-单例模式

设计模式：解决某一类问题最有效的方式
单例设计模式：解决的是类在内存中只有一个对象的问题
 　　1.一个类不能有多个对象，那么构造方法不能被使用（构造方法私有化）
  　　　　private 类名(){}
 　　2.构造方法private之后，一个对象都不能创建了
   　　 私有的构造方法在本类中是可以使用的
   　　 在本类中创建一个对象
 　　3.为了防止外界随意操作这个对象，修饰为private
 　　4.为了能让外界得到这个唯一的对象,需要定义一个方法
           因为类不能创建对象，所以该方法必须是public static的， 由于方法是静态的，所以创建对象也必须是static的，

   ·单例设计模式中的：懒汉式与饿汉式

//饿汉式
class QianFeng
{
   private static QianFeng qf=new QianFeng();
   private QianFeng(){}
   public static QianFeng getInstance(){
       return qf;
    }   
}
//懒汉式
class Single{
    private static Single single;//null
    private Single(){}
    public static Single getInstance(){
         if(single==null)
             single=new Single();
         
         return single;
    }
}

class Demo2 {
    public static void main(String[] args) {
        //QianFeng qianfeng = QianFeng.getInstance();
        //QianFeng qianfeng2 = QianFeng.getInstance();
        //System.out.println(qianfeng==qianfeng2);

        Single s1=Single.getInstance();
        Single s2=Single.getInstance();

        System.out.println(s1==s2);
    }
}

   ·继承（extends）：

　　子类继承父类的属性和行为
       作用： 1.  实现了代码的重复使用   2.使类和类之间产生了关系。

java中的继承是单继承的：
    单继承：一个类可以继承另外一个类
    多继承：一个类可以继承多个类
    java支持多层继承。A extends B, B extends C。
为什么是单继承的： 因为多继承会出现调用的不确定性。

父类中定义的是子类共性的东西，子类除了具备父类的东西还可以定义自己特有的东西，所以子类比父类功能更多

class Demo6 {
    public static void main(String[] args) {
        System.out.println("Hello World!");
    }
}
class Person  //父类 是子类的共性的属性和行为
{
    String name;
    int age;

    public void eat(){
       System.out.println("吃吃吃");
    }
}
class Student extends Person{
    public void study(){
       System.out.println("study");
    }
}

class Worker extends Person
{
    public void work(){
       System.out.println("工作");
    }

}

class A{
    public void laugh(){
       System.out.println("傻笑");
    }
}
class B extends A{
    public void eat(){
       System.out.println("吃饭");
    }
}
class C extends A{
}
class D extends B{
}

   ·继承中成员变量的特点：

   当子父类中出现同名的属性或方法时，使用super来区分，super表示访问他的父类，super. 。
   父类中的属性都定义成private的，子类继承了但是无权使用，所以父类需要定义public的set和get方法，子类通过这些public方法来使用属性

//继承中成员变量的特点
// 当子父类中出现同名的属性或方法时，使用super来区分
class Fu{
    private int num=6;
    public void setNum(int num){
       this.num=num;
    }
    public int getNum(){
       return num;
    }
}
class Zi extends Fu{
    public void show(){
       System.out.println(getNum());//继承过来了，但无权使用,通过public的方法来使用属性
    }
}
class Demo7 {
    public static void main(String[] args) {
        Zi z = new Zi();
        z.show();
    }
}

 

   ·重写

继承中成员方法的特点：
       子类和父类有相同的行为，但是行为的表现方式不同，java认为子类没有必要单独再定义一个方法，所以有了重写，也叫覆盖，
重写(覆盖)：子类中出现了和父类一样的方法，当创建子类对象，调用这个方法时，执行的总是重写之后的。

重写的前提：存在继承。

重写注意事项：
   父类中private的方法不能被子类重写
   子类在重写时，方法权限要大于等于父类中方法的权限   public>=public
   父类中的方法是静态的，子类在重写时必须是静态的。

class Fu{
    public void show(){
       System.out.println("show fu");
    }
    public static void ff(){
       System.out.println("static fu");
    }
}
class Zi extends Fu{
    public void show(){
       System.out.println("show fu");
    }
    public static void ff(){
       System.out.println("static zi");
    }
}
class Demo8 {
    public static void main(String[] args) {
         Zi z = new Zi();
         z.show();

        //ZhangXiaoSan xiaosan =new ZhangXiaoSan();
        //xiaosan.eat();
    }
}
class ZhangSan{
    public void eat(){
        System.out.println("细嚼慢咽的吃");
    }
}
class ZhangXiaoSan extends ZhangSan{
     //子类和父类有相同的行为，但是行为的表现方式不同
    //java认为子类没有必要单独再定义一个方法
    public void eat(){
       //super.eat();
       System.out.println("狼吞虎咽的吃");
    } 
}

   ·继承中构造函数的特点：

在创建子类对象时，总是先执行父类的构造函数，再执行子类的构造方法。
 原因是系统自动在子类的构造方法的第一行加入了super();调用父类中无参的构造方法。

 构造方法不能被继承。

为什么先执行父类的构造方法：因为子类继承父类必然会继承父类的属性，先执行父类的构造方法可以利用父类构造方法中为属性赋值的语句

注意：一个类都要写空参的构造方法
系统默认有无参构造函数，如果自己写了，系统默认的无参构造函数就没了，自己可以再加一个无参构造函数。

class Fu{
    private int age;
    private String name;
    String address;
    int weight;

    Fu(){}

    Fu(int age,String name,String address,int weight){
      this.age=age;
      this.name=name;
      this.address=address;
      this.weight=weight;
    }
    public int getAge(){
      return age;
    }
    public String getName(){
       return name;
    }
}
//构造方法不能被继承
class Zi extends Fu{
    Zi(){//super();}

    Zi(int age,String name,String address,int weight){
      super(age,name,address,weight);//自己写了super语句，系统就不再加入super();
    }
}
class Demo9 {
    public static void main(String[] args) {
        Zi z = new Zi();
         //Zi z = new Zi(20,"李四","北京",200);
         //System.out.println(z.getAge()+","+z.getName());
    }
}

   ·继承中this与构造函数

　　下列代码第11行，由于this调用构造方法时，this（）必须在第一行，而super()是系统自带的，所以super()加不进去，不会执行super()

class Fu{
    int age;
    
    Fu(int age){
      this.age=age;
    }
}

class Zi extends Fu{
    Zi(){
      this(20);//super(); 加不进来，因为第一行已经被占用
    }
    Zi(int age){
      super(age);
    }
}
class Demo10 {
    public static void main(String[] args){
        Zi z = new Zi();
        System.out.println(z.age);
    }
}

 day8

   ·final修饰符

1.final:是一个修饰符，可以修饰类，方法，成员变量，局部变量

final 修饰类：该类不能被继承
final 修饰方法：该方法不能被子类重写（覆盖）
final 修饰成员变量，变量的值不能被修改
final 修饰局部变量，变量的值不能被修改

   ·单例和final

 引用类型被final修饰，意思是该引用不能指向其他对象

/*
class Test
{
   public final void show()
    {
       System.out.println("show");
    }
}
class B extends Test
{
    public  void show()
    {
       System.out.println("hello");
    }
}
*/
//计算圆形的面积
class Circle
{
    public static final double PI=3.1415;//值不能被修改，符号常量，程序中用到的固定的数据，用符号常量表示

    //public static final int PAY=1;
    //public static final int NOPAY=2;
    private double radius;

    Circle(){}

    Circle(double radius){
       this.radius=radius;
    }
    public double area(){
       return  PI*radius*radius;
    }
}
class Demo1{
     public static void main(String[] args) {
         final int a=6;
         //a=99;//无法为最终变量a分配值
         int num=add(5,5);
         System.out.println(num);
    }
    public static int add(final int a,final int b)//当希望接收到的值不能被修改时
{
        //a=66;
        //b=99;
        return a+b;
    }
}
//单例
class Single {
    private static final Single single=new Single();//引用类型被修饰为final，意思是该引用不能指向其它对象
    private Single(){}
    public static Single getInstance(){
        //single=new Single();
        return single;
    }
}

   ·abstract 抽象  

例：public abstract void 吼叫();    //没有实现的方法----抽象方法

抽象方法不能被调用，因为该方法没有实现
抽象类，是在对子类提取共性的过程中，出现了无法确定如何实现的行为，因为子类对该行为有各自的表现方式，
那么父类不确定该如何实现该方法，所以父类就不实现该方法，该方法就成了抽象方法，所以这个父类就是抽象类了。

abstract class 犬科动物{    
    int age;
    public void eat(){
      System.out.println("吃肉");
    }
    public abstract void 吼叫();// 没有实现的方法----抽象方法
}
class 狼 extends 犬科动物{   
    public void 吼叫(){
        System.out.println("嗷嗷叫");
    }
}
class 狗 extends 犬科动物{
    public void 吼叫(){
        System.out.println("汪汪叫");
    }
    public static void main(String[] args){
       犬科动物 d=new 犬科动物();
       d.吼叫();//抽象方法不能被调用，因为该方法没有实现
    }
}

   ·抽象类的特点：

   1.抽象类不能创建对象
   2.一个类继承了抽象类，如果没有重写父类中的抽象方法，那么这个类也是抽象类
      （子类含有抽象方法，那么该子类也是抽象类）
抽象类一定是父类吗    一定

抽象类和普通类的区别：
   共同点：都是类 能被继承
   不同点：抽象类不能创建对象，普通类可以创建对象
 抽象类含有抽象方法，普通类不含有抽象方法

抽象类有构造函数吗
   不能创建对象，但是有构造函数，构造函数是给子类使用的。

abstract不能喝哪些关键字同时使用：
   static：静态方法可以通过类名调用，abstract修饰的方法不能被调用 ；（一起用会报错非法的修饰组合：abstract和static）
   final:   final修饰的方法不能被重写，abstract方法必须能被重写。
   private:私有的方法不能被重写，abstract方法必须能被重写。

抽象类不一定含有抽象方法 （当希望一个类不能被创建对象时，这个类修饰为abstract，但是这个类中没有抽象方法）
但是含有抽象方法的类一定是抽象类

 

abstract class Person{
  public void eat()
  {
  }
  public void sleep()
  {
  }
}
//计算圆形和长方形面积
abstract class Shape{
   public  abstract double area();//非法的修饰符组合: abstract和static  Shape.area()  非法的修饰符组合: abstract和private
}

abstract class Circle extends Shape{
    public static final double PI=3.1415;
    private double radius;

    Circle(){}
    Circle(double radius){
      this.radius=radius;
    }

    //该子类含有抽象方法，那么该子类也是抽象类

    /*
    public double area()//需要重写父类中的抽象方法，否则该子类也是抽象类
    {
       return PI*radius*radius;
    }
    */
}

 class Rectangle extends Shape{
    private double length;
    private double width;

    Rectangle(){}
    Rectangle(double length,double width){
       this.length=length;
       this.width=width;
    }
    public double area(){
        return length*width;
    }
}
class Demo3 {
    public static void main(String[] args) {
        //Shape shape=new Shape();//Shape是抽象的; 无法实例化
        Rectangle rectangle=new Rectangle(8,5);
        double mianji = rectangle.area();
        System.out.println(mianji);
        Person ren = new Person();
    }
}

/*
需求：公司中程序员有姓名，工号，薪水，工作内容。
项目经理除了有姓名，工号，薪水，还有奖金，工作内容。
对给出需求进行数据建模。
*/
abstract class Employee{
    private String name;
    private int number;
    private double salary;
    Employee(){}
    Employee(String name,int number,double salary){
       this.name=name;
       this.number=number;
       this.salary=salary;
    }
   public abstract void work();
}
class Programmer extends Employee{
    Programmer(){}
    Programmer(String name,int number,double salary){
        super(name,number,salary);
    }
    public  void work(){
       System.out.println("敲代码");
    }
}
class Manager extends Employee{
    private double bonus;
    Manager(){}
    Manager(String name,int number,double salary,double bonus){
        super(name,number,salary);
        this.bonus=bonus;
    }
    public void work(){
       System.out.println("管理程序员");
    }
}
class Demo4 {
    public static void main(String[] args) {
    Programmer yuan=new Programmer("猿","007",20000);
    yuan.work();
    Manager manager=new Manager("老猿","009",50000,10000);
    manager.work();
        System.out.println("Hello World!");
    }
}

   ·接口：interface 

interface 接口名
{      
     public static final 成员变量                 //注意：这里不写public static final，属性也是这种
     public abstract 成员方法                   
 }
接口是用来实现的，用implements ，
接口解决java单继承的问题，接口是可以多实现的：因为接口中的方法都是抽象的，当创建子类对象调用这个方法时，
   很明确是在调用重写之后的方法，不会出现调用不确定的情况。

interface inter{
     public static final int NUM=66;
     public abstract void show();
     //jdk1.8开始，可以定义实现了的方法
     public default void fun(){
        System.out.println("ok");
     }
}
interface inter2{
     public abstract void show();
     /*
     public default void fun()
     {
        System.out.println("kk");
     }*/
}
class Test implements inter,inter2 //类就继承了接口中的成员
{
     public  void show(){
         System.out.println("Hello");
     }
}
class Demo5 {
    public static void main(String[] args) {
         Test t = new Test();
         System.out.println(inter.NUM);
         System.out.println(Test.NUM);
         System.out.println(t.NUM);
         t.fun();
    }
}

   ·Lambda表达式

lambda表达式jdk1.8之后推出的新特性。本质上来说，lambda表达式就是一个匿名函数。可以使用lambda表达式简洁的实现接口中的方法。

interface Calculate {
    int calculate(int a, int b);
}
class Addition implements Calculate {
    @Override
    public int calculate(int a, int b) {
        return a + b;
    }
}

class Program {
    public static void main(String[] args) {
        // 给接口类型的引用进行赋值，右侧需要是这个接口的实现类类型对象。
        Calculate calculate = new Addition();
        int result = calculate.calculate(10, 20);
        
        // 如果使用lambda表达式来完成同样的操作
        Calculate calculate2 = (a, b) -> a + b;
        int result2 = calculate2.calculate(10, 20);
    }
}

lambda表达式对接口的要求

并不是所有的接口都可以使用lambda表达式来实线。lambda表达式毕竟只是一个匿名方法，如果接口中只有一个方法必须要实现，则可以使用lambda表达式；但是如果接口中必须要实现的方法比较多。

lambda表达式只能对 函数式接口 进行简洁的实现。

   ·lambda表达式的基础语法

lambda表达式，从本质来讲，就是一个匿名方法。一个方法的组成，有 返回值、方法名、参数、方法体 部分。

而lambda表达式是匿名方法，所以，方法名可以忽略。另外，在lambda表达式中，返回值类型也可以忽略。

因此，对于lambda表达式只需要关注两点即可：

• 参数 ： 以（）括起来，将参数写入到（）中。

• 方法体 ： 以 {} 括起来，将方法体写入到 {} 中。

对于lambda表达式，还需要记住一个新的语法： ->

• lambda运算符 -> : 可以分隔参数和方法体。

// 说明需要实现一个无参、无返回值的方法
() -> { System.out.println("hello world"); }
// 说明需要实现一个 (int, int) 参数的、int返回值的方法
(int a, int b) -> { return a + b; }

// 无参无返回
NoneParameterNoneReturn lambda1 = () -> {
    System.out.println("hello world");
};
lambda1.test();            // 最终的实现，是lambda表达式中的实现


// 多个参数、有返回
MutipleParameterSingleReturn lambda2 = (int x, int y) -> {
    return x + y;
};
int ret2 = lambda2.test(10, 20);
System.out.println(ret2);

   ·lambda表达式的语法进阶

lambda表达式是为了简洁的实现接口的，所以某些部分是可以省略的。

1、参数的类型，已经在接口的方法中有明确规定了，因此在lambda表达式中，可以省略参数的类型。

   注意：如果要省略形参的类型，则每一个形参都必须省略。不能出现有的形参带类型，有的没有。

MutipleParameterNoneReturn lambda1 = (a, b) -> {
    System.out.println("a = " + a + ", b = " + b);
};
lambda1.test(10, 20);

2、如果参数列表中，形参的数量只有一个，此时可以省略小括号。

SingleParameterNoneReturn lambda2 = a -> {
    System.out.println("a = " + a);
};
lambda2.test(10);

lambda表达式的函数引用

---

推理：

lambda表达式可以简洁的实现一个接口，但是，一般情况下，在lambda表达式中的都是简单的逻辑。如果需要处理的逻辑比较复杂，不推荐将复杂的逻辑直接的写到lambda表达式中。

 

如果需要在lambda表达式中进行的复杂的逻辑处理，已经在其他的方法中实现过了，可以直接调用这个方法即可。或者可以使用函数引用，将引用的函数，实现接口中的方法。

public class CSyntax {
    public static void main(String[] args) {
        // 需求: 
        // 计算a和b的最大公约数
        
        // 这是个函数引用，使用calculate方法实现接口中的方法
        MutipleParameterSingleReturn lambda = CSyntax::calculate;
        
        int result = lambda.test(12, 8);
        System.out.println(result);
    }
    
    public static int calculate(int a, int b) {
        // 1、找出最小值
        int min = a > b ? b : a;
        // 2、从最小值开始，向下递减直到1，找到一个能够同时整除a和b的数字
        for (int i = min; i >= 1; i--) {
            if (a % i == 0 && b % i == 0) {
                return i;
            }
        }
​
        return -1;
    }
}

 

构造方法的引用

如果接口中的方法，需要返回一个对象，则此时，可以引用构造方法。

public class DSyntax {
    public static void main(String[] args) {
        /*
        GetPerson lambda = () -> new Person();
        Person xiaoming = lambda.get();
        System.out.println(xiaoming);
        */
        // 引用的构造方法
        GetPerson lambda2 = Person::new;
        System.out.println(lambda2.get("xiaoming", 10));
    }
}
​
interface GetPerson {
    Person get(String name, int age);
}
​
​
class Person {
    String name;
    int age;
    
    public Person() {
        super();
        System.out.println("Person的无参构造方法执行了");
    }
    public Person(String name, int age) {
        super();
        this.name = name;
        this.age = age;
        System.out.println("Person的有参构造方法执行了");
    }
    
    @Override
    public String toString() {
        return "Person [name=" + name + ", age=" + age + "]";
    }
}

   ·继承和实现结合：

 类和类之间是继承关系，类和接口之间是实现的关系，接口和接口之间是继承的关系
 通过继承可以得到体系中的基本的功能和属性
 通过实现可以得到体系以外的功能和属性

interface inter{
    public abstract void show();
}
class Person{
    int age;
    String name;
    public void eat()
    {}
}
class Student extends Person implements inter{
    public  void show()
    {
    }
}
interface a{
}
interface b {
}
interface c extends a,b{
}

 

/*
狗生活在陆地上（是一种陆生动物），既是哺乳类的也是肉食性的。
狗通常的时候和人打招呼会通过“摇摇尾巴”，在被抚摸情绪很好的时候，
会“旺旺叫”，而在受到惊吓情绪烦躁时，会发出“呜呜”声；

猫也生活在陆地上（是一种陆生动物），既是哺乳类的也是肉食性的。
猫通常的时候和人打招呼会发出“喵～”的声音，在被抚摸情绪很好时，
会发出“咕噜咕噜”声，而在受到惊吓时，会发出“嘶嘶”声；

青蛙是一种两栖动物（既是水生动物也是陆生动物），既不是哺乳类的也不是肉食性的，
属于卵生。青蛙通常的时候和人打招呼会通过“呱呱叫”，当青蛙情绪好的时候，
会在岸边“呱呱呱”的唱歌，而在受到惊吓时，会“扑通一声跳入水中”
*/
abstract class Animal
{
    public static final int HAPPY=1; // 1表示情绪好
    public static final int UNHAPPY=2;//2表示情绪不好
    protected boolean mammal;//哺乳
    protected boolean carnivorous;//肉食
    private int mood;

    public boolean isMammal(){
        return mammal;
    }
    public boolean isCarnivorous(){
        return carnivorous;
    }
    public void setMood(int mood){
        this.mood=mood;
    }
    public int getMood(){
       return mood;
    }
    public abstract String sayHello();
    public abstract String sayHello(int mood);
}
interface Land{
    public abstract int getNumberOfLegs();
}
interface Warter{
    public abstract boolean getGillFlags();
    public abstract boolean getLayEggsFlags();
}
class Dog extends Animal implements Land{
    private int numberOfLegs=4;//几条腿
    Dog(){
       this.mammal=true;
       this.carnivorous=true;
    }
    public  String sayHello(){
       return "摇摇尾巴";
    }
    public  String sayHello(int mood){
         setMood(mood);
         switch(getMood()){
           case HAPPY:
                 return "旺旺叫";//break;
           case UNHAPPY:
                 return "呜呜";

           default:
                 return "摇摇尾巴";
         }
    }
    public  int getNumberOfLegs(){
        return numberOfLegs;
    }
}
class Demo7 {
    public static void main(String[] args){
        Dog gou = new Dog();
        if(gou.isMammal())
            System.out.println("狗是哺乳动物");
        else
            System.out.println("狗不是哺乳动物");

        if(gou.isCarnivorous())
            System.out.println("狗是肉食动物");
        else
            System.out.println("狗不是肉食动物");

        System.out.println("狗通常情况下打招呼的方式是:"+gou.sayHello());

        System.out.println("狗情绪好时打招呼的方式是:"+gou.sayHello(Animal.HAPPY));

        System.out.println("狗受到惊吓时打招呼的方式是:"+gou.sayHello(Animal.UNHAPPY));

        System.out.println("狗是陆生动物，狗有"+gou.getNumberOfLegs()+"条腿");

    }
}

   ·多态

　　父类类型的引用指向子类对象，即把子类对象看成父类类型 ，
多态的弊端：在多态中只能使用父类中定义的行为，父类中未定义的不能使用
多态的前提：存在继承或实现
多态的优点：通常都是方法的参数使用多态，这样可以接收所有父类的子类类型的对象，节省了很多函数的定义

abstract class Animal{
    public abstract void eat();
}
class Cat extends Animal{
    public  void eat(){
       System.out.println("猫吃鱼");
    }
    public void catchMouse(){
       System.out.println("猫抓耗子");
    }
}
class Demo9 {
    public static void main(String[] args) {
        //Cat mao = new Cat();
        //mao.eat();
        //mao.catchMouse();

        Animal mao = new Cat();
        mao.eat();
        //mao.catchMouse();//错误: 找不到符号 mao.catchMouse();
    }
}

   ·多态中如何使用子类特有的功能 ---转型

向上转型

• 由子类类型转型为父类类型。

• 向上转型一定会成功，不需要任何额外的操作，是一个隐式转换。

• 向上转型后的对象，将只能够访问父类中存在的成员，子类特有的成员将无法访问。

向下转型

• 由父类类型转型为子类类型。

• 向下转型存在失败的可能性，需要额外进行强制操作，是一个显式转换。

• 向下转型后的对象，将可以访问子类中特有的成员。

 由于多态中，父类引用指向子类对象，只能使用父类中定义的行为；
 方法如：Animal mao=new Animal(); //向上转型
       Cat m=(Cat)mao; //向下转型   强转
                      instanceof(实例)用于判断对象具体是什么类型的

abstract class Animal{
    public abstract void eat();
}
class Cat extends Animal{
    public  void eat(){
       System.out.println("猫吃鱼");
    }
    public void catchMouse(){
       System.out.println("猫抓耗子");
    }
}
class Dog extends Animal{
    public  void eat(){
       System.out.println("狗吃肉");
    }
    public void kanJia(){
        System.out.println("狗看家");
    }
}
class Demo11 {
    public static void main(String[] args) {
        //在多态中使用子类特有的功能
        Animal  mao = new Cat();//向上转型
        //使用子类特有的功能
        Cat m=(Cat)mao;//向下转型
        //m.eat();
        //m.catchMouse();

        Cat cat = new Cat();
        chi(cat);

        Dog gou = new Dog();
        chi(gou);
    }

     //使用子类特有的功能
    public static void chi(Animal dongwu)//Animal dongwu=new Dog();
    {
        dongwu.eat();

        if(dongwu instanceof Cat)//使用instanceof判断对象具体是什么类型的
        {
            Cat mao = (Cat)dongwu;
            mao.catchMouse();
        }
        if(dongwu instanceof Dog){
           Dog gou = (Dog)dongwu;
           gou.kanJia();
        }
    }
}

day9

   ·重写的特殊情况

重写总结：
 public father run(){}
 public son run(){}  //是重写

 

 protect a run(){}
 public a run(){}  //是重写
 

 私有的private修饰的方法不能被重写
 

    子类在重写父类中的方法时，如果父类中的方法返回值是本身，本身当引用数据类型，那么子类在重写时，可以和父类方法的返回值一致，也可以是父类方法返回值类型的子类类型

class Test{
       public Fu show(){
           return new Z1();
       }
}
class Tests extends Test{
     public Z2 show() //子类在重写时返回值类型可以和父类方法一致，也可以是父类方法返回值的子类类型
     {
         return new Z2();
     }
}
class Fu{
    public void fun(){
        System.out.println("fun");
    }
}
class Z1 extends Fu{    
}
class Z2 extends Fu{
}
class Demo2 {
    public static void main(String[] args) {
        Tests t = new Tests();
        Z2 z = t.show();
        z.fun();
    }
    public static Fu ff(){
       return new Z2();
    }
}

 

   ·接口和多态

多态同样适用于接口
 一个方法的参数类型可以是接口类型
 一个方法的返回值类型可以是接口类型

interface inter //接口是引用数据类型 inter.class{
    public abstract void show();
}
class Test1 implements inter{
    public  void show(){
       System.out.println("show1");
    }
}
class Test2 implements inter{
    public  void show(){
       System.out.println("show2");
    }
}
class Demo3 {
    public static void main(String[] args) {
        Test1 t1 = new Test1();
        ff(t1);

        Test2 t2 = new Test2();
        ff(t2);

        inter t=fun(); //inter t=new Test1()　　 注释的此行就是接口可用于多态的核心
        t.show();
    }
    public static inter fun()//返回值类型是接口类型
    {
       return new Test1();
    }
    public static void ff(inter in)//inter in=new Test2();父接口类型的引用指向了子类对象
    {
        in.show();
    }
}

   ·多态中成员的特点

/*
多态中成员的特点：

成员变量的特点：编译时期看父类，运行结果看父类
非静态成员方法的特点: 编译时期看父类, 运行结果看子类
静态成员方法的特点：编译时期看父类，运行结果看父类

非静态成员方法看子类，其它的都看父类
*/
class Fu{
    int num=5;
    
    public void show(){
       System.out.println("show fu");
    }
    public static void ff(){
        System.out.println("fu static");
    }
}
class Zi extends Fu{
    int age=6;

    public void show(){
       System.out.println("show zi");
    }
    public void fun(){
       System.out.println("fun");
    }
    public static void ff(){
        System.out.println("zi static");
    }
}
class Demo4 {
    public static void main(String[] args) {
        Fu zi=new Zi();
        //System.out.println(zi.num);
        //System.out.println(zi.age);
        //zi.show();
        //zi.fun();
        zi.ff();
    }
}

   ·object

是任何一个类的直接或间接父类，超类，最大的那个类，Object没有父类
 Object提取的是所有对象的共性：Object中定义的属性和行为是任何一个对象都具备的
 构造方法Object(){}

object中的方法：equals()方法，
 toString()方法，返回的是对象的字符串表示形式，由类名加哈希值(16进制)组成。
 如果直接输出对象，默认调用了对象的toString的方法
 hashCode()方法，返回对象的哈希值(10进制)

   ·模板设计模式

模板设计模式：实现一个功能，功能的一部分是能确定，一部分是不能确定的，确定的那部分会用到不确定的部分，
                把不确定的部分暴露出去，让子类去实现

/*
模板设计模式：实现一个功能时，功能的一部分是能确定如何实现的，一部分不能确定如何实现，确定的那部分会用到不确定的部分
              把不确定的部分暴露出去，让子类去实现

 计算程序的运行时间

*/
abstract class Test{
    public final void runTime(){
        //记录开始时间
        long start = System.currentTimeMillis();
        //程序代码
        fun();
        //记录结束时间
        long end = System.currentTimeMillis();
        System.out.println("程序运行时间:"+(end-start));
    }
    public abstract void fun();
}
class Demo extends Test{
    public  void fun(){
        for(int i=1;i<=3000;i++){
            System.out.println(i);
        }
    }
}
class Demo6 {
    public static void main(String[] args) {
        Demo d = new Demo();
        d.runTime();
    }
}

   ·内部类

在一个类内部定义的类，属于外部了的成员，成员内部类，成员之间可以相互使用

外部类Outer，内部类Inner，使用的时候，为Outer.Inner
非静态内部类对象的创建：由于内部类是非静态的，需要外部类对象调用，所以使用外部类对象创建内部类对象
 Outer.Inner inner=new Outer().new Inner();

      内部类看成外部类的成员
      内部类既然是成员，所以可以被修饰为static的
      内部类中含有静态成员，那么内部类必须是静态的
      内部类得到外部类对象 : 外部类名.this

//内部类：在一个类内部定义的类,属于外部类的成员，成员内部类，成员之间可以相互使用
//static可以修饰成员
class Outer{
    private int num=66; //成员变量
    class Inner //成员内部类
    {
        public void show(){
           System.out.println(num);
           fun();
        }
    }
    public  void  fun()//成员方法
    {
       Inner in = new Inner();
       in.show();
    }
}

class Person{
   class Heart{
    }
}

class Demo7 {
    public static void main(String[] args) {
        //Outer out = new Outer();
        //out.fun();
        //创建内部类对象，因为内部类是非静态的，所以需要创建Outer的对象
        Outer.Inner inner=new Outer().new Inner();
        inner.show();
    }
}

class Outer{
    private static int num=6;
    static class Inner  //内部类中的成员是静态的，那么内部类必须是静态的
    {
        public static void show() // new Outer().new Inner().show()   new Outer.Inner() Outer.Inner.show()
        {
           System.out.println(num);
        }
    }

}

class Demo8 {
    public static void main(String[] args) {
        //因为show方法不是静态的，所以必须通过Inner的对象来调用
        //访问静态内部类中的非静态方法
        Outer.Inner in = new Outer.Inner();
        in.show();

        //访问静态内部类中的静态方法
        Outer.Inner.show();
    }
}

//内部类得到外部类对象:  外部类名.this
class Outer{
    private int num=6;
    class Inner{
        int num=8;
        public void show(){
           int num=7;
           System.out.println(Outer.this.num);
        }
    }
    
    public void fun(){
       Inner in = new Inner();
       in.show();
    }
}
class Demo9{
    public static void main(String[] args) {
        Outer out = new Outer();
        out.fun();
    }
}

   ·局部内部类

在一个类的函数里的类

//局部内部类
class Outer{
    public void fun(){
       class Inner{
           public void show(){
              System.out.println("Hello");
           }
       }
       new Inner().show();
    }
}
class Demo10 
{
    public static void main(String[] args) 
    {
        Outer out = new Outer();
        out.fun();
    }

 

   ·匿名内部类

在类的方法里，   new  类 (){};

/*
匿名内部类：作用是为了简化书写
*/
abstract class Test{
    public abstract void show();
}
class Outer{
    /*
   class Inner extends Test{
       public  void show(){
          System.out.println("show");
       }
       public void fun(){
           System.out.println("fun");
       }
   }
   */
   public void ff(){
        //Inner in = new Inner();
        //in.show();
        //in.fun();
        //创建的是Test的子类对象
        new Test(){
            public  void show(){
              System.out.println("show");
            }
            public void fun(){
               System.out.println("fun");
            }
        }.show();

        //父类类型的引用指向了子类对象
        Test t = new Test(){
            public  void show(){
              System.out.println("show");
            }
            public void fun(){
               System.out.println("fun");
            }
        };
        t.show();//只能调用show方法

        System.out.println(new Object(){
            String name="李四";
            int age=20;
             
            public String toString(){
               return name+","+age;
            }
        });
    }
}
class Demo11 {
    public static void main(String[] args) {
        Outer out = new Outer();
        out.ff();
    }
}

 

   ·private

子类继承父类，子类拥有了父类的所有属性和方法。（private 自己的，私有的）
　　私有属性不能直接得到，私有属性可以通过public修饰的getter和setter方法访问到，但是私有方法不行。

       私有方法不能被重写可以被重载，私有方法可通过public方法得到。

day10

   ·接口(interface)与匿名内部类

注意
 a.run().start(); //因为.start()需要对象调用，所以run()的返回值是一个对象

 

interface T{
    abstract void start();
}
class A{
    public static void main(String args[]){
        A a=new A();
        a.run().start();
    }
    public static T run(){
        return new Test();
    }
}
class Test implements T{
    public void start(){
        System.out.println("start方法被调用了");
    }
}

 

   ·String : 字符串类

   java把字符串面向对象，定义了一个描述字符串的类 String
   特点：字符串是不能改变的，它们的值在创建后不能更改
            字符串是存储在方法区中的常量池中 (如果常量池中已经存在一个字符串那么直接使用已有的字符串)
   常量：不能被修改的量，由于字符串存储在方法区的常量池中，所以双引号里的内容不能被修改

 

String类重写了Object中的boolean equals(Object obj)方法和toString方法
equal：比较双引号中的内容(字符串中的内容是否一样)
   String str1=new String("1000"); //有两个对象，一个是new的对象，一个是字符串对象
   String str2="1000";
   String str3="1000";2
   str1.equals(str2); 
//返回值是false，由于str1指向的是new String 在堆中的地址
   str2.equals(str3); //返回值是true，由于两个都直接取了"1000"的值

总之：equals比较“”里面的，（老师说的）

 

数组中的length是属性

获取字符串的长度 int length()；
String中的length() 如"1000".length(), 是方法

 

//判断用户名和密码是否正确
     //参数：用户名和密码 admin,admin
     //返回值：boolean

     public static boolean check(String username,String password){
        if(username!=null && password!=null){
             if(username.equals("admin") && password.equals("admin"))
                 return true;
             else
                 return false;
         }
         else
             return false;
     }

   ·String类中的各种方法

length(), char charAt(int index),int indexOf(char ch),int indexOf(String ch,int start), int lastIndexOf(char ch)

/*
  获取：
     获取字符串的长度
        int length()
     获取某一个位置上的字符
        char charAt(int index)
     获取字符在字符串中的位置
     如果要找的字符或者字符串不存在，返回值为-1
        int indexOf(char ch)//返回字符在字符串中第一次出现的位置
        int indexOf(int ch, int fromIndex)//第二个参数用于指定开始找的位置

        int indexOf(String str) //获取一个字符串在字符串中出现的位置
        int indexOf(String str, int fromIndex)//第二个参数用于指定开始找的位置

        int lastIndexOf(char ch)//最后一次出现的位置
*/

class Demo4 {
    public static void main(String[] args) {   
        int num = "oiwueroieuro".length();
        sop(num);//数组的length,是属性

        char ch="hello".charAt(1);
        sop(ch);

        int index = "hello wo ".indexOf('o');//返回第一次出现的下标
        sop(index);//4

        index = "hello wo hoo".indexOf('o',6);// 指定开始查找的位置
        sop(index);//7

        index="hello world".indexOf("llo");
        sop(index);//2

        index="hello world llo".indexOf("llo",5);
        sop(index);//12

        index="hello world llo".lastIndexOf("llo");//最后一次出现的下标
        sop(index);//12

        index="haha".indexOf('w');
        sop(index);//-1
    }
    public static void sop(Object obj){
       System.out.println(obj);
    }
}

   ·String类中的其它方法

 length(), char charAt(int index),int indexOf(char ch),int indexOf(String ch,int start), int lastIndexOf(char ch)

     contains()  equals() startsWith() endsWith() equalsIgnoreCase()

     new String(char[] ch)  "lsjdkl".toCharArray()    new String(byte[] arr)  "oiwueori".getBytes()

     "   oiwueroe   ieri    ".trim()  toUpperCase()  toLowerCase()   replace(old,new)

/*
   判断：
        判断是否包含一个字符串
          boolean contains(CharSequence s) 
        判断两个字符串的内容是否相同
          boolean equals(Object anObject) 
        忽略大小写判断两个字符串的内容是否相同
          boolean equalsIgnoreCase(String anotherString) 
         判断是否以某字符串开头
           boolean startsWith(String prefix)
         判断是否以某字符串结尾
           boolean endsWith(String suffix) 
    转换：将字符数组转换成字符串
              1:使用构造方法
                 String(char[] value) 
                 String(char[] value, int offset, int count) 
              2:使用静态方法
                 static String copyValueOf(char[] data) 
                 static String copyValueOf(char[] data, int offset, int count) 
          将字符串转成字符数组
              char[] toCharArray() 
 
          将字节数组转成字符串
              String(byte[] bytes) 
              String(byte[] bytes, int offset, int length)
              String(byte[] bytes, String charsetName)//使用指定的编码将字节数组转换成字符成
          将字符串转成字节数组
              byte[] getBytes() 
 

          将基本数据类型转换成字符串
              String.valueOf()
    替换：
         String replace(char oldChar, char newChar) 
 
    子串:
         String substring(int beginIndex)  
         String substring(int beginIndex, int endIndex) //包含起始位置，不包含结束位置，到结束位置的前一位
 
    转换，去除空格，比较:
         大小写转换
             String toLowerCase() 
             String toUpperCase()
         将字符串两端的空格去掉
             String trim() 
         按字典顺序比较两个字符串
             int compareTo(String anotherString)
    切割: String[] split(String)

*/
class Demo5 {
    public static void main(String[] args) {
        //panDuan();
        //zhuanHuan();
        //qiTa();
        lasts();
    }

    public static void lasts(){
        //按字典顺序比较两个字符串  int compareTo(String anotherString)
        int num = "a".compareTo("c");//前边的小于后边的返回负数，前边大于后边，返回一个正数，前边等于后边返回0
        sop(num);//0

        //切割: String[] split(String str)
        String str="zhangsan,lisi,wangwu,zhaoliu";
      
        String[] arr=str.split(",");  
        sop(arr.length);
        for(int i=0;i<arr.length;i++){
          sop(arr[i]);
        }
    }

    public static void qiTa(){
        // String replace(char oldChar, char newChar)
        String  ss="hello".replace('e','w');  //"hello"没有被改变，是根据hello得到了一个新的字符串
        sop(ss);

        String s1="hello world".substring(6);
        sop(s1);

        s1="hello world".substring(6,9);//包含起始位置，不包含结束位置，到结束位置的前一位
        sop(s1);

        s1="hello world".substring(6,7);//StringIndexOutOfBoundsException 第二个值不要小于第一个值
        sop(s1);

        sop("hello".toUpperCase());
        sop("HELLO".toLowerCase());

        sop("   hehe     ".trim());
    }

    public static void zhuanHuan()
    {
        //将字符数组转换成字符串
        char[] arr={'a','b','c','d'};  //"abcd"

        //使用构造方法 String(char[] value) 
        String str = new String(arr);
        sop(str);//abcd
        
        //static String copyValueOf(char[] data)
        String ss = String.copyValueOf(arr,1,3);
        sop(ss);//bcd

        //将字符串转成字符数组   char[] toCharArray() 
        char[] b = "hello".toCharArray();
        for(int i=0;i<b.length;i++){
          sop(b[i]+"  ");
        }

        //将字节数组转成字符串
        byte[] c={65,66,67,68};
        String ss2=new String(c);
        sop(ss2);

         //将字符串转成字节数组
        byte[] d = ss2.getBytes();
        for(int i=0;i<d.length;i++){
          sop(d[i]+"  ");
        }

        //将基本数据类型转换成字符串 String.valueOf()
        String ss3=String.valueOf(new Demo5());
        sop(ss3);
    }

    public static void panDuan(){
        boolean b = "hello world".contains("wo");
        sop(b);

        b = "hello".equals("hello");
        sop(b);

        b="hello".equalsIgnoreCase("HELLO");//忽略大小写
        sop(b);//true

        b="my.java".endsWith(".java");
        sop(b);

        b="my.java".startsWith("my");
        sop(b);
    }

    public static void sop(Object obj){
       System.out.println(obj);
    }
}

   ·StringBuffer

　　字符串缓冲区
　　可以被改变的字符串序列（与String类的区别）
append();往字符串中添加， 里面可以是任意类型的

Object中的toString()输出的是类名+哈希值
StringBuffer中的toString()重写了Object中的toString()，输出的是字符串

StringBuffer:jdk1.0，线程安全的，可以安全地被多个线程使用 （适合多线程）
StringBuilder：多线程不安全的，提高代码执行效率

//StringBuffer:可变的字符序列
/*
存储：
    StringBuffer append(boolean b) 
    StringBuffer insert(int offset, boolean b) 
删除：
     StringBuffer delete(int start, int end) 
     StringBuffer deleteCharAt(int index)
修改：
     StringBuffer replace(int start, int end, String str) 
     void setCharAt(int index, char ch) 
获取：
     char charAt(int index) 
     int indexOf(String str)
     int indexOf(String str, int fromIndex)
     int lastIndexOf(String str) 
          返回最右边出现的指定子字符串在此字符串中的索引。 
     int lastIndexOf(String str, int fromIndex) 
          返回最后一次出现的指定子字符串在此字符串中的索引。 
     int length() 
          返回长度（字符数）。 
反转：
     StringBuffer reverse() 


StringBuffer:JDK1.0,线程安全的，可以安全地被多个线程使用

StringBuilder:可变的字符序列,jdk1.5,多线程不安全的，提高代码执行效率

*/
class Demo6 {
    public static void main(String[] args) {
        //String str= new String("hello");

        StringBuffer sb = new StringBuffer("hello"); //添加，修改，删除

       // StringBuffer sb1=sb.append(false);//添加完之后返回的还是原来的StringBuffer对象
        //sop(sb==sb1);

         //加入对象时加入的是对象的字符串表示：类名+哈希值
        sb.append(66).append(true).append(new Object());//加入到StringBuffer的都被转成字符串


        //得到StringBuffer中的字符串
        //sop(sb.toString());//StringBuffer重写了Object中的toString方法,返回的是存储的字符串
        

        sb.insert(5,"world");
        sop(sb);

       //删除
       sb.delete(5,10);//不包括结束位置
       sop(sb);

       sb.deleteCharAt(5);
       sop(sb);

       //修改
       sb.replace(6,10,"false");
       sop(sb);

       sb.setCharAt(5,'8');
       sop(sb);

      //反转
      sb.reverse();
      sop(sb);        
    }
    public static void sop(Object obj){
       System.out.println(obj);
    }
}

   ·StringBuilder

StringBuffer:jdk1.0，线程安全的，可以安全地被多个线程使用 （适合多线程）
StringBuilder：多线程不安全的，提高代码执行效率（适合单线程）

class Demo7 {
    public static void main(String[] args) {
        boolean b =checkEmail("zhangsan163.com");
        //System.out.println(b);
        juXing(5,10);
    }
    //显示一个矩形，用StringBuilder存储一个矩形，并打印
     //参数：行，列
     //返回值:无
     public static void juXing(int row,int col){
         StringBuilder sb = new StringBuilder();
         for(int i=1;i<=row;i++){
            for(int j=1;j<=col;j++){
                sb.append("*");
             }
             sb.append("\r\n");
         }
        System.out.print(sb.toString());
     }

    //验证邮箱格式是否正确  lisi@163.com
    //参数：字符串类型的邮箱
    //返回值：boolean

    public static boolean checkEmail(String email) {
        if(email!=null){
            if(email.indexOf("@")==-1)
                return false;
            else if(email.indexOf(".")==-1)
                return false;
            else if(email.indexOf("@")>email.indexOf("."))
                return false;
            else
                return true;
        }else
            return false;
    }
}

   ·包装类 及 String的相关转换

把基本类型变为引用类型，即java的面向对象的思想，由类来调用方法，提高程序的编写。

byte  Byte
short  Short
int Integer
long Long
char  Character
float Float
double  Double
boolean  Boolean

/*
包装类：
  基本类型转字符串类型三种方式
　　　String new String(int a);　//String new String (int[] arr)   数组转字符串
　　
　　　String String.valueOf(double d)
  String Double.toString(double d)

　　　String String.valueOf(int a);
  String Integer.toString(int a)

  字符串类型转基本类型两种方式
  int    Integer.parseInt("66")
  Integer i=Integer.valueOf("66"); int i2=i;

 十进制转其他进制
        String s1=Integer.toHexString(60);
        String s2=Integer.toOctalString(60);
        String s3=Integer.toBinaryString(60);

其他进制转十进制
       Integer.parseInt("3c",16)
       Integer.parseInt("74",8)
       Integer.parseInt("110",2)
*/
class Demo8 {
    public static void main(String[] args) {
        char ch='我';
        int max=Integer.MAX_VALUE;
        sop(max);

        String str = Integer.toString(66);//String.valueOf()
        sop(str);
        sop(""+66);

        int age = Integer.parseInt("66");
        sop(age);
        double weight=Double.parseDouble("88.88");
        sop(weight);

        //十进制转其他进制

        String s1=Integer.toHexString(60);
        sop(s1);
        String s2=Integer.toOctalString(60);
        sop(s2);
        String s3=Integer.toBinaryString(60);
        sop(s3);

        //其他进制转十进制
        sop(Integer.parseInt("3c",16));
        sop(Integer.parseInt("74",8));
        sop(Integer.parseInt("110",2));
    }
    public static void sop(Object obj){
       System.out.println(obj);
    }
}

   ·装箱与拆箱  

自动装箱 Integer num=6;   //jdk1.5之后     相当于Integer num=new Integer(6)

自动拆箱　int n=num;　　//自动拆箱，
自动拆箱   num=num+5;     //num.intValue()+5       先拆箱，再装箱    
装箱与拆箱的具体细节，由系统内部完成

在一个字节的范围内（-128---127），如果已经使用过，那么再定义时使用已有的

class Demo9 {
    public static void main(String[] args) {
        //jdk1.5之前的写法
        Integer shu = new Integer(6);
        System.out.println(shu.intValue());//此方法能得到6

        Integer num=6;// new Integer(6)  自动装箱
        System.out.println(num);
　　　　　　
　　　　　　int n=num;　　　　//自动拆箱，将num拆成了int

        num=num+5;//num.intValue()+5  先拆箱 11--->Integer  再装箱

        Integer m=127;  //new Integer(127) int m=127;
        Integer n=127;
        System.out.println(m==n);//true

        m=128;
        n=128;
        System.out.println(m==n);//false

        //在一个字节的范围内（-128---127），如果已经使用过，那么再定义时使用已有的
    }
}

 

package com.zqf;
public class Test{
    public static void main(String args[]){
        int n=128;
        int x=128;
        Integer m=128;
        Integer z=128;
        System.out.println(z==m);//不在-128---127内，所以z用的对象是新创建的对象
        
        System.out.println(m==n);
        System.out.println(n==x);
        
        System.out.println(z==n);
        Integer d=127;
        Integer e=127;
        System.out.println(d==e);    //在-128---127内，所以e用的对象还是d的对象
    }    
}

 

day11

   ·异常

定义：程序在运行时出现的不正常情况

java把程序运行时出现的各种不正常情况面向了对象，为各种不正常情况封装了实体类，
实体类应该实现显示异常名称，异常信息，异常发生的位置

 

   Throwable:（Error类和Exception类的父类）
      -- Error： 错误

      --Exception：异常

当发生异常时,因为这种异常对应的异常类在Java内部已经定义了，所以系统会创建对应该异常的异常类对象，因为main处理不了这种异常，
抛给了JVM，JVM默认的处理方式是调用异常类对象的printStackTrace()方法，该方法会显示异常名称，异常信息，异常发生的位置， 然后程序中断

class Demo10 {
    public static void main(String[] args) {
        int[] arr=new int[3];
        System.out.println(arr[3]);  //throw  new ArrayIndexOutOfBoundsException()  printStackTrace()方法
        System.out.println("hehe");    
    }
}

 

 try{
 可能发生异常的代码
}catch(异常类 e){
 e.getMessage()
 e.toString()
 e.printStackTrack()
 }finally{

 　　　　//finally中的代码一定会执行，除非catch中有system.exit(1);

}

默认情况下，可以处理也可以不处理，存在的问题是程序编译通过，运行时发生异常，应该让问题在编译时期就发现，
而不是编译正常，运行出问题，使用throws

没有使用throws时，调用者处理或不处理编译都通过，存在的问题是编译正常，运行出问题，
使用了throws，调用者必须处理，不处理编译不通过

一个方法使用了throws声明了异常，必须进行处理
两种处理方式：
   使用try{}catch{}
   使用throws继续声明异常

 

多重异常：
 try{}catch{}...catch{}
当catch中有子类异常，也有父类异常时，子类异常在父类异常之前。（要是父类异常在子类异常之前，就都能处理了，会在编译时报错）

异常：
 Excepiton的子类,编译时检测的异常
 RuntimeException或其子类
 其子类有arithmeticException,NullPointException(),ArrayIndexOutOfBoundsException()等...

编译时不检测，运行时检测的异常：RuntimeException或其子类，这种异常是因为传递数据出错，
java认为此时应该程序中断，希望人为的将参数改成正确的，否则影响后面的代码使用

是因为数据错误造成的，当发生这种异常时，不该处理，就应该中断程序，去修改错误

//定义了一个被除数为负数时，会产生的异常
package com.zqf;
class fuShuException extends Exception{
    public fuShuException(String message) {
        super(message);
    }
    public static void run(int a,int b) {
        if(a<0){
            try{throw new fuShuException("负数异常啊 ，秀啊");  //手动创建异常类对象
            
            } catch (fuShuException e) {
                System.out.println(e.getMessage());
                e.printStackTrace();
            }
        }
        int c=a/b;
        System.out.println(c);
    }
    public static void main(String[] args)  {
        run(-1,2);
    }
}

 

任何执行try 或者catch中的return语句之前，都会先执行finally语句，如果finally存在的话。
                  如果finally中有return语句，那么程序就return了，所以finally中的return是一定会被return的，

 　　　　注：finally子句是异常处理的出口，释放资源、关闭文件、关闭数据库都是由finally子句完成

day12

   ·异常总结

throw: 抛出异常类对象，java定义的异常类不需要自己手动创建异常类对象，自定义的需要字节手动创建异常类对象
           在方法内部使用了throw，该方法必须处理，处理方式有两种，捕获或声明，如果不处理，编译不通过

throws：在方法的后边声明可能发生异常，调用了有throws声明的方法，调用者必须处理，处理方式有两种，捕获或声明，如果不处理，编译不通过

非运行时异常符合上边的规则

运行时异常：
 传参错误的是运行时异常
 特殊的异常，不符合上边的规则RuntimeException或其子类
 在方法内部使用了throw抛出了运行时异常对象，那么可以不处理
 使用throws声明了运行时异常，可以不处理
 
 因为运行时异常都是因为数据错误造成的，如果处理了，比如使用try{}catch{}处理了，那么发生异常时，
 会执行catch，然后程序继续执行，但是应该让程序停下来，去解决错误的数据，所以不该处理

 运行时异常可以处理，但是不好

自定义异常：
   如果是运行时异常不需要处理，非运行时异常处理

 

   ·Date及SimpleDateFormat

import java.util.Date;
import java.text.DateFormat;
import java.text.SimpleDateFormat;
//java.lang.System;
class Demo2 {
    public static void main(String[] args) {
        Date date = new Date();
        //sop(date);//Wed Sep 11 10:43:26 CST 2019

        long time=System.currentTimeMillis();// 1970.1.1 0点
        //sop(time);

        //把一个long类型的时间的毫秒值转成Date类型
        Date d=new Date(time);
        //sop(d);

        //把Date类型的日期格式进行转换，转成成容易看的格式
        //得到具备格式化功能的对象
        DateFormat  df =DateFormat.getDateTimeInstance(DateFormat.FULL,DateFormat.SHORT);
        //String format(Date date) 
        String str = df.format(new Date());
        //sop(str);

        //创建日期格式化对象，同时指定格式
        SimpleDateFormat sdf =new SimpleDateFormat("yyyy-MM-dd  HH:mm:ss");
        String ss = sdf.format(new Date());
        sop(ss);
    }

    public static void sop(Object obj){
        System.out.println(obj);
    }
}

 

1、将一个Date对象转成指定格式的时间字符串

```java
Date date = new Date();
// 1、实例化SimpleDateFormat对象
//   但是，一般情况下，实例化的同时，会设置格式化的格式
//   2019-10-14 10:58:45
//   y:年    M:月        d:日     H:时(24)        h:时(12)        m:分        s:秒        S:毫秒
//   年: yyyy长年分    yy短年份
//   月: MM    如果月份不到10，会往前补0         M
//   
SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
// 2、将date进行格式化
String timeStr = sdf.format(date);
```



2、将指定格式的时间字符串转成Date对象

```java
String str = "2019-10-14 17:54:68";

// 1、实例化一个SimpleDateFormat对象
SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");

// 2、解析
try {
    Date date = sdf.parse(str);
    System.out.println(date);
    
} catch (ParseException e) {
    e.printStackTrace();
}
```

 

   ·calendar

import java.util.Calendar;
class Demo3 {
    public static void main(String[] args) {
        Calendar cal=Calendar.getInstance();
        //sop(cal.toString());

        String[] months={"1月","2月","3月","4月","5月","6月","7月","8月","9月","10月","11月","12月"};
        String[] weeks={"","星期日","星期一","星期二","星期三","星期四","星期五","星期六"};

        int nian = cal.get(Calendar.YEAR);
        int yue = cal.get(Calendar.MONTH);
        int ri = cal.get(Calendar.DAY_OF_MONTH);

        int week=cal.get(Calendar.DAY_OF_WEEK);

        sop(nian+"年"+months[yue]+ri+"日,"+weeks[week]);
    }
    public static void sop(Object obj){
        System.out.println(obj);
    }
}

 

   ·Math及Random

import java.util.Random;
class Demo4{
    public static void main(String[] args) {
        sop(Math.ceil(56.6));//返回大于这个数的最小整数，返回值是double类型

        sop(Math.floor(56.6));//返回小于这个数的最大整数，返回值是double类型

        sop(Math.pow(2,3));//计算2的3次方

        sop(Math.sqrt(4));//开方

        sop(Math.abs(-5));//绝对值

        sop(Math.round(5.8));//四舍五入取整

        sop(Math.random());//生成大于等于0.0小于1.0的随机数，

        //生成1-10之间的随机数
        /*
        for(int i=1;i<=5;i++){
            sop((int)(Math.ceil(Math.random()*10)));
        }*/

        Random r = new Random();
        for(int i=1;i<=5;i++){
           sop(r.nextInt(10)+1);// >=1 <11
        }
    }
    public static void sop(Object obj){
        System.out.println(obj);
    }
}

 

   ·正则表达式

　　专门针对字符串的，为了简化操作

　　正则表达式，最主要是用来做字符串的校验、匹配。校验一个字符串是否满足指定的规则。

1.正则表达式匹配的规则：依次比较字符串中的每一个字符，和正则表达式中定义的规则进行校验。

2.字符串的边界匹配

// ^: 匹配一个字符串的开头
// $: 匹配一个字符串的结尾
// 在java中matches，正则表达式会自动的添加一个^$
System.out.println("hello world".matches("^hello world$"));

3.一位字符的匹配

// []: 匹配一位字符
// [abc]: 这一位字符可以是a，也可以是b，也可以是c
System.out.println("aello world".matches("[hwl]ello world"));
// [^abc]: 这一位的字符可以是除了a、b、c之外的任意字符
System.out.println("aello world".matches("[^hwl]ello world"));
// [a-z]: 这一位的字符可以是[a,z]之间的任意字符
System.out.println("Hello world".matches("[a-z]ello world"));
// [^a-z]: 这一位的字符可以是除了 [a,z] 之外的任意字符
System.out.println("Hello world".matches("[^a-z]ello world"));
// [a-zA-Z0-9]: 这一位的字符可以是任意的字母或数字
System.out.println("Hello world".matches("[a-zA-Z0-9]ello world"));
// [^a-z[klt]]: 这一位的字符不可以是a-z之间的任意字符，但是klt除外
System.out.println("lello world".matches("[^a-z[klt]]ello world"));

// .: 表示通配符，可以匹配任意的一位字符
System.out.println("hello world".matches(".ello world"));
// 转义字符: \
System.out.println(".ello world".matches("\\.ello world"));


// \d: 匹配所有的数字 [0-9]
// \D: 匹配所有的非数字 [^0-9]
// \w: 匹配所有的单词字符 字母数字下划线
// \W: 匹配所有的非单词字符 非字母数字下划线
System.out.println("hello world".matches("\\Dello world"));

4.多位匹配

// +: 前面的一位或者一组字符，连续出现了1次或多次。
// ?: 前面的一位或者一组字符，连续出现了0次或1次。
// *: 前面的一位或者一组字符，连续出现了0次、1次或多次。
System.out.println("helo".matches("hell+o"));
System.out.println("heo".matches("hel?o"));
System.out.println("hello".matches("hel*o"));

// {m}: 前面的一位或者一组字符，连续出现了m次。
// {m,}: 前面的一位或者一组字符，连续出现了至少m次。
// {m,n}: 前面的一位或者一组字符，连续出现了至少m次，最多n次。
System.out.println("helllllllllo".matches("hel{2,10}o"))

5、或 |

一般是用在一个分组中，表示这个分组中的内容可以是几种情况之一。组成的几种情况，长度可以不一样。

System.out.println("fine, thank you, and you".matches("hello|hi|nihao|你好"));

 

 

 

 

class Demo5{
    public static void main(String[] args) {
        //正则表达式:专门针对字符串的

        boolean b = checkQQ("7654320987aaa");

        String regex="[1-9]\\d{4,14}";//正则本身也是字符串    两个\表示一个\，代表转义的作用，\d表示第二个为数字，{4，14}表示数字字少有4，最多14个
        
        boolean boo = "928349sddtt493".matches(regex);

        sop(boo);
        //sop(b);
    }

    //验证QQ号的功能 ：5-15，不能以0开头，全是数字 "923y98374908"
    public static boolean checkQQ(String qq){
          int length=qq.length();
          if(length>=5 && length<=15){
              if(!qq.startsWith("0")){
                  try{
                    long num= Long.parseLong(qq);//NumberFormatException
                    return true;
                  }catch(NumberFormatException e)
                  {   
                  }
              }else
                  sop("qq号以0开头了");
          }else
              sop("qq号长度不合法");
          return false;
    }
    public static void sop(Object obj){
        System.out.println(obj);
    }
}

class Demo6 
{
    public static void main(String[] args) {
        String regex="bo?k";  // * 0次或多次，？ 0次或1次    +  1次或多次
        boolean b = "bok".matches(regex);
        sop(b);
    }
    public static void sop(Object obj){
        System.out.println(obj);
    }
}

   ·正则表达式针对字符串的常用操作：

正则：专门针对字符串的
匹配：  boolean matches(String regex)
切割：  String[] split(String regex)
替换：  String replaceAll(String regex,String str)
获取：1：根据要获取的内容定义正则表达式
          2：根据正则表达式得到Pattern对象
          3：使用Pattern对象得到Matcher对象
          4：使用Matcher对象的find()方法来查找，找到了返回true，否则返回false
          使用Matcher对象的group()方法获取找到的内容

import java.util.regex.Pattern;
import java.util.regex.Matcher;
class Demo7 {
    public static void main(String[] args) {
        //piPei();
        //qieGe();
        // tiHuan();
        huoQu();
    }
    public static void huoQu(){
        //从字符串中获取四个字母构成的词儿
        String str="zhu yi la, ming tian fang jia";
        String regex="[a-z]{4}";

        //把正则表达式转换成Pattern类型的对象
        Pattern pattern = Pattern.compile(regex);

        //使用Pattern类型的对象得到Matcher类型的对象，Matcher对象具备获取的功能
        Matcher m = pattern.matcher(str);

        while(m.find()) //find()方法找到了返回true，没找到返回false
        {
           System.out.println(m.group()); // group()方法返回找到的符合正则表达式的内容
        }    
    }
    public static void tiHuan(){
        //String str="zhangsan*****lisi############wangwu&&&&&&&&zhaoliu";
        //String regex="(.)\\1+";
        //String ss = str.replaceAll(regex,"$1");//在正则表达式之外取某一组的值使用$

        //String str="owieuowe9827349287498324iwsjdhfkshd049586045860456wesdf765432109";
        //String regex="\\d{8,}";
        //String ss = str.replaceAll(regex,"****");

        String str="15699788866";
        String regex="(\\d{3})\\d{4}(\\d{4})";
        String ss = str.replaceAll(regex,"$1****$2");
        System.out.println(ss);
    }
    public static void qieGe(){
        //String str="zhangsan.lisi.wangwu.zhaoliu";
        //String regex="\\.";//普通字符点儿

        //String str="zhangsan   lisi      wangwu         zhaoliu";
        //String regex=" +";

        String str="zhangsan*****lisi############wangwu&&&&&&&&zhaoliu";
　　　　　　//下面的(.)中，.是代表任意字符，()代表分组，\\1被转义为第二组要和第一组的数相同，+表示这个组至少还有一个或多个
        String regex="(.)\\1+";//()用来分组，从左到右，依次是第一组，第二组

        String[] arr = str.split(regex);
        for(int i=0;i<arr.length;i++){
          System.out.print(arr[i]+"  ");
        }
    }
    public static void piPei(){
        //验证手机号是否合法
        String regex="1[34578]\\d{9}";

        boolean b = "12838384381".matches(regex);

        System.out.println(b);
    }
}

 

   ·集合（包装类）

用于存储不同类型的对象，

集合和数组的区别：

　　集合：可以存储不同类型的对象，随着存储的对象的增加，集合的容量也会随着增大

　　数组：数组的长度是固定的，另外java提供的数组的功能有限

 

 

class Cat{}
class Person{}
class BoSiMao extends Cat{}
class Demo8 {
    public static void main(String[] args) {
         Object[] arr=new Object[10];
         arr[0]=new Cat();
         arr[1]=new Person();
         arr[2]=new Object();

         Cat[] mao = new Cat[5];
         mao[0]=new BoSiMao();
    }
}

   ·collection接口

　　(不能操作下标，子接口list可以)

/*
Collection中定义的是整个集合体系最共性的功能

添加：
   boolean add(Object o) 
   boolean addAll(Collection<? extends E> c)  
删除:
   boolean remove(Object o)  
   boolean removeAll(Collection<?> c)
   void clear()
判断:
   boolean contains(Object o) 
   boolean containsAll(Collection<?> c)
   boolean isEmpty() //判断集合是否为空
   boolean equals(Object o) 
获取：
   Iterator<E> iterator() //获取集合中的对象
   int size() //获取集合中对象的个数
集合变数组：
   Object[] toArray()
*/
import java.util.*;
class Demo9 {
    public static void main(String[] args) {
        Collection coll=new ArrayList();

        coll.add("java1");
        coll.add("java2");
        coll.add("java3");
        coll.add(88);

        //sop(coll);

        Collection c = new ArrayList();
        c.add("hadoop");
        c.add("mysql");

        coll.addAll(c);//把别的集合中的数据加入到当前集合中
        sop(coll);

        //删除集合中某个对象
        coll.remove(88);
        sop(coll);

        coll.removeAll(c);
        sop(coll);

        //coll.clear();//清空集合，删除集合中所有对象
        //sop(coll);

        boolean boo = coll.contains("java1");
        //sop(boo);

        //coll.clear();
        //sop(coll.isEmpty());//判断集合是否为空

        boo = coll.equals(c);
        sop(boo);

        sop(coll.size());//3

         //Object[] toArray()

         Object[] arr = coll.toArray();
         for(int i=0;i<arr.length;i++)
             sop(arr[i]);
    }

    public static void sop(Object obj){
        System.out.println(obj);
    }
}

 

 day13

    ·迭代器

因为集合中存储的是多个数据，需要一个一个的取到每个数据，这就叫集合的遍历
//Iterator<>  iterator()    //该方法返回一个Iterator接口的子类对象

 

 

 

package com.zqf;

import java.util.*;
class  Demo1{
    public static void main(String[] args) {   
        //因为集合中存储的是多个数据，需要一个一个的取到每个数据，这就叫集合的遍历

        // Iterator<E> iterator() //该方法返回一个Iterator接口的子类对象(也是ArrayList的内部类对象)，该对象可以实现对集合的遍历
        ArrayList coll =new ArrayList();

        coll.add("java");
        coll.add("hadoop");
        coll.add("mysql");

        Iterator ite = coll.iterator();//拿到了内部类对象

        while(ite.hasNext()){
            Object obj =  ite.next();
            String str = (String)obj;
            sop(str.toUpperCase());
        }
    }
    public static void sop(Object obj){
       System.out.println(obj);
    }
}

 

   ·list接口   ArrayList类

　　（需要掌握）

/*
Collection中定义的是整个集合体系最共性的功能
    ---List(子接口)：存储的数据是有序的（集合中数据的顺序和添加数据的顺序是一致的），存储的数据是可以重复的
        
List接口特有的功能都是可以操作下标的功能

增：
    void add(int index, E element) 
    boolean addAll(int index, Collection<? extends E> c) 

删
   E remove(int index) 

改
   E set(int index, E element)

查
     ListIterator<E> listIterator() 
     返回此列表元素的列表迭代器（按适当顺序）。 
     ListIterator<E> listIterator(int index) 

     List<E> subList(int fromIndex, int toIndex) 
     E get(int index) 
*/
import java.util.*;
class Demo2 {
    public static void main(String[] args) {
        List coll =new ArrayList();

        coll.add("java");
        coll.add("hadoop");
        coll.add("mysql");

        coll.add(1,"h5");
        //sop(coll);

        //coll.remove(1);
        //sop(coll);

        coll.set(1,"python");
        //sop(coll);

        //List<E> subList(int fromIndex, int toIndex)  截取子集合
        List list = coll.subList(1,3);
        //sop(list);

        //Object obj = coll.get(1);
        //sop(obj);
      /*
        Iterator ite = coll.iterator();
        while(ite.hasNext()){
           Object obj = ite.next();
           sop(obj);
        }

        for(Iterator it=coll.iterator();it.hasNext();){
            Object o=it.next();
            sop(o);
        }

        for(int i=0;i<coll.size();i++){
           sop(coll.get(i));
        }*/

        while(!coll.isEmpty()){
            sop(coll.remove(0));//remove会返回被删除的对象
        }

        sop(coll.size());
    }

    public static void sop(Object obj){
       System.out.println(obj);
    }
}

 

   ·list接口     Vector类

　　（了解即可）

/*
Collection中定义的是整个集合体系最共性的功能
    ---List(子接口)：存储的数据是有序的（集合中数据的顺序和添加数据的顺序是一致的），存储的数据是可以重复的
            ArrayList：底层使用的数据结构是数组，线程不安全的，查找数据的速度快(内存是连续的)，增删速度慢
            Vector:底层使用的数据结构是数组,线程安全的,查找数据的速度快，增删速度慢
*/
import java.util.*;
class Demo3 {
    public static void main(String[] args) {
        Vector v = new Vector();
        v.add("java01");
        v.add("java02");
        v.add("java03");

        Enumeration en = v.elements();
        while(en.hasMoreElements()){
            Object obj=en.nextElement();
            sop(obj);
        }
    }
    public static void sop(Object obj){
       System.out.println(obj);
    }
}

   ·List接口   LinkedList类

　　（了解即可）

/*
Collection中定义的是整个集合体系最共性的功能
    ---List(子接口)：存储的数据是有序的（集合中数据的顺序和添加数据的顺序是一致的），存储的数据是可以重复的    
            ArrayList：底层使用的数据结构是数组，线程不安全的，查找数据的速度快(内存是连续的)，增删速度慢
            Vector:底层使用的数据结构是数组,线程安全的,查找数据的速度快，增删速度慢
            LinkedList:底层使用的数据结构是链表，线程不安全的，查找数据的速度慢，增删速度快

LinkedList特有的功能：

void addFirst(E e) 
void addLast(E e) 

getFirst() 
getLast() 

removeFirst() 
removeLast() 

jdk1.6才出现以下方法（暂不掌握）

offerFirst()  
offerLast()

peekFirst()
peekLast()

pollFirst()
pollLast()
*/
import java.util.*;
class Demo4 {
    public static void main(String[] args) {
        LinkedList list=new LinkedList(); 

        list.addFirst("java1");
        list.addFirst("java2");
        list.addFirst("java3");

        //sop(list);
        while(!list.isEmpty()) {
           sop(list.removeFirst());//先进后出
        }
        //list.getFirst();//集合中没有则异常
        list.peekFirst();//集合中没有不会异常

        //list.removeFirst();//NoSuchElementException
        list.pollFirst();//集合中没有不会异常
    }
    public static void sop(Object obj){
       System.out.println(obj);
    }
}

 

import java.util.*;

//使用LinkedList实现队列，使队列面向对象
//自定义一个队列（先进先出）
class Queues{
     private LinkedList link;

     Queues(){
         link=new LinkedList();
     }
     //入队
     public void enQueue(Object obj){
         link.addLast(obj);
     }
     //出队
     public Object deQueue(){
        return link.removeFirst();
     }
     //队列是否为空
     public boolean isNull(){
        return link.isEmpty();
     }    
}
class Demo5 {
    public static void main(String[] args) {
        Queues duilie = new Queues();

        duilie.enQueue("hehe");
        duilie.enQueue("haha");
        duilie.enQueue("xixi");
        
        while(!duilie.isNull()){
            sop(duilie.deQueue());
        }
    }
    public static void sop(Object obj){
       System.out.println(obj);
    }
}

   ·小练习

import java.util.*;
class Demo6 {
    public static void main(String[] args) {
        ArrayList list =new ArrayList();

        list.add("java01");
        list.add("java02");
        list.add("java03");
        list.add("java01");
       
        ArrayList lists=quChong(list);

        System.out.println(lists);
    }
    //去除集合中的重复数据 :参数：集合，返回：集合
    public static ArrayList quChong(ArrayList list){ 
        ArrayList list2=new ArrayList();
        for(int i=0;i<list.size();i++){
            Object obj = list.get(i);
            if(!list2.contains(obj))
                list2.add(obj);
        }
        return list2;
    }
}

 

abstract class Drink{
    abstract void taste();
    public void getDrink(int drinkType){
        switch(drinkType){
            case 1:System.out.println("咖啡");
            case 2:System.out.println("牛奶");
            case 3:System.out.println("啤酒");
       }
        return ;
    }
}
abstract class Coffee extends Drink{
    private int drinkType;
    void taste(int drinkType){
        this.drinkType=drinkType;
    }
    void taste(){
        System.out.println("咖啡的味道:香味浓郁，有持久水果味。 ");
    }
    }
    abstract class Milk extends Drink{
        private int drinkType;

        void taste(int drinkType){
            this.drinkType=drinkType;
    }
    void taste(){
        System.out.println("牛奶的味道:淡而醇");
    }
}
abstract class Beer extends Drink{
    private int drinkType;

    void taste(int drinkType){
       this.drinkType=drinkType;
    }
    void taste(){
        System.out.println("啤酒的味道:苦而辣");
    }
}
public class Test{
    public static void main(String[]args){
        Coffee c1=new Coffee(){};
        Milk m1=new Milk() {};
        Beer b1=new Beer() {};
        c1.taste(1);
        c1.taste();
        m1.taste(2);
        m1.taste();
        b1.taste(3);
        b1.taste();
    }
}

 

 day14

Collection

   List:有序，可以重复（ 可以存储相同的对象）

      ArrayList:数组，内存连续，查找速度快

      LinkedList:链表，内存不连续，查找慢，增删快

         contains方法是依据equals方法，当有特殊需求时，需要重写equals方法

   Set:无序，不可以重复（ 不可以存储相同的对象）

      HashSet:无序，不可以重复，底层是哈希表 ，线程不安全，保证不重复：int hashCode()(哈希算法)    boolean equals(Object obj)
             

      TreeSet:排序，无序，不可以重复 ，底层是二叉树，线程不安全 ，在使用add方法添加对象时，就调用compareTo方法进行了比较大小 

       Comparable：默认TreeSet调用加入到集合的对象的compareTo方法来确定谁大谁小，所以通常只要对象所属的类实现了
     Comparable接口的compareTo方法，就可以排序，compareTo返回值为0认为是同一个对象，不加入集合

       Comparator：如果对象所属的类实现了 Comparable接口的compareTo方法，但是比较方式不是我们需要的，那么需要自定义
     比较方式，自定义的比较方式需要实现Comparator接口的int compare方法，compare返回值为0认为是同一个对象，不加入集合

 

   ·contains的具体实现

/*
  Collection中定义的是整个集合体系最共性的功能    Iterator hasNext()  next()

    ---List(子接口)：存储的数据是有序的（集合中数据的顺序和添加数据的顺序是一致的），存储的数据是可以重复的
            
            ArrayList：底层使用的数据结构是数组，线程不安全的，查找数据的速度快(内存是连续的)，增删速度慢
                 
            Vector:底层使用的数据结构是数组,线程安全的,查找数据的速度快，增删速度慢
                   Enumeration   hasMoreElements()   nextElement()

            LinkedList:底层使用的数据结构是链表，线程不安全的，查找数据的速度慢，增删速度快
*/
import java.util.*;
class Student{
    private String name;
    private int  age;

    Student(){}

    Student(String name,int age){
       this.name=name;
       this.age = age;
    }

    public boolean equals(Object obj){
        if(!(obj instanceof Student))
            throw new RuntimeException("类型不对");

        Student stu=(Student)obj;

        System.out.println(this.name+"对比:"+stu.name);
        return this.name.equals(stu.name)&&this.age==stu.age;
    }

    public String toString(){
      return name+","+age;
    }
}
class  Demo1{
    public static void main(String[] args) {
        //需求：姓名年龄相同的认为是同一个人，对集合去重
        ArrayList list =new ArrayList();

        list.add(new Student("lisi",12));
        list.add(new Student("wangwu",27));
        list.add(new Student("zhaoliu",19));
        list.add(new Student("lisi",12));

        ArrayList jihe = quChong(list);
        sop(jihe);    
    }
    public static ArrayList quChong(ArrayList list){ 
        ArrayList list2=new ArrayList();
        for(int i=0;i<list.size();i++){                                                        
            Object obj = list.get(i);                          
            if(!list2.contains(obj))//判断是不是包含某个对象，内部依据的是equals方法
                list2.add(obj);
        }
        return list2;
    }
    public static void sop(Object obj){
       System.out.println(obj);
    }
}

   

   ·Set接口   HashSet类

/*
   ----Set:没有特有的功能

           存储的数据是无序的（集合中数据的顺序和添加数据的顺序不一致），存储的数据是不可以重复的
        
       HashSet:如何保证对象不重复的：依据的是int hashCode()方法（哈希值）和 boolean equals(Object obj)方法
                （底层使用的数据结构是哈希表，线程是不安全的）
               向集合中添加对象时，先用要添加的对象的哈希值和集合中已有的对象的哈希值分别比较，当哈希值都不相同
               时，对象直接加入集合，当出现了哈希值相同的对象时，再调用equals方法对两个对两个对象比较，equals方法
               返回true，怎认为是同一个对象，不加入集合，否则认为是不同的对象，加入集合

               注意:哈希值相同的不一定是同一个对象，同一个对象哈希值一定相同
                    考虑不可重复时，使用HashSet
       
*/
import java.util.*;
class Person{
    public int hashCode(){
       return 88;
    }
    public boolean equals(Object obj){
      return true;
    }
}
class Demo2 {
    public static void main(String[] args) {
        HashSet hs = new HashSet();

        hs.add(new Person());
        hs.add(new Person());// 88  new Person().equals(new Person()); false
        hs.add(new Person());//88
        
        sop(hs);
        /*
       //在使用add方法添加对象时就保证了对象的唯一
       hs.add(66);  66.hashCode()
       hs.add(77);
       hs.add(99);
       hs.add(66);*/

       sop(hs);   
    }
    public static void sop(Object obj){
       System.out.println(obj);
    }
}

   HashSet的运用

import java.util.*;
class Student{
    private String name;
    private int  age;

    Student(){}

    Student(String name,int age){
       this.name=name;
       this.age = age;
    }

    public int hashCode(){
       return name.hashCode()+age*66;
    }

    public boolean equals(Object obj){
         if(!(obj instanceof Student))
             throw new RuntimeException("类型错误");

         Student stu = (Student)obj;
         return this.name.equals(stu.name)&&this.age==stu.age;
    }

    public String toString(){
      return name+","+age;
    }
}
class Demo3 {
    public static void main(String[] args) {  
        HashSet hs = new HashSet();
         //需求：姓名年龄相同的认为是同一个对象，不能被加入集合

        hs.add(new Student("lisi",19));
        hs.add(new Student("zhaoliu",29));//不同的对象哈希值肯定不同（前提：没有重写hashCode方法）
        hs.add(new Student("wangwu",17));
        hs.add(new Student("lisi",19));

        sop(hs);

        boolean boo=hs.contains(new Student("lisi",19)); //也是依据 hashCode() 方法和equals方法
        sop(boo);//true

        hs.remove(new Student("lisi",19));//也是依据 hashCode() 方法和equals方法
        sop(hs.size());
    }
    public static void sop(Object obj){
       System.out.println(obj);
    }
}

 

   ·Set接口   TreeSet类

/* 
       TreeSet: 具备Set的基本特征，还可以进行排序

                TreeSet排序是调用添加到集合中的对象的compareTo()方法确定下来谁大谁小
                才能排序的，所以如果添加到集合中的对象所属的类没有实现compareTo方法，TreeSet是不能排序的

                底层数据结构使用的是二叉树(红黑树):
*/
import java.util.*;
class Person implements Comparable  //只要是实现了Comparable接口的就是可以排序的
{
    public int compareTo(Object obj){
         return 9;
    }
}
class Demo4{
    public static void main(String[] args) {
        TreeSet ts = new TreeSet();

        ts.add(new Person());//
        ts.add(new Person());// new Person().compareTo(new Person())
        ts.add(new Person());//new Person().compareTo(new Person())  new Person().compareTo(new Person())

        sop(ts);

        /*
        //在使用add方法添加时就比较大小了  因为String类实现了Comparable接口中的compareTo方法，所以TreeSet可以对字符串进行排序
        ts.add("hello");
        ts.add("aaabbbccc");
        ts.add("dell");
        ts.add("hello");  //"hello".compareTo("hello")==0  compareTo方法的返回值为0，认为是同一个对象，不加入集合

        sop(ts);
        */
    }
    public static void sop(Object obj){
       System.out.println(obj);
    }
}

   ·comparable接口与compareTo()

   Comparable: 默认是TreeSet调用加入到集合的对象的cmopareto方法来确定谁大谁小， 所以通常只要对象所属的类实现了comparable接口的compareTo方法，就可以排序

 

package com.zqf;
import java.util.*;
public class Test{
    public static void main(String[] args) {
        Set<Person> set=new TreeSet<Person>();
        set.add(new Person("zhangsan",12));
        set.add(new Person("lisi",14));
        set.add(new Person("wanger",13));
        System.out.println(set);
    }
}
class Person implements Comparable<Person>{
    private String name;
    private int age;
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    public int getAge() {
        return age;
    }
    public void setAge(int age) {
        this.age = age;
    }
    public Person(String name, int age) {
        super();
        this.name = name;
        this.age = age;
    }
    public Person() {
        super();
    }
    @Override
    public String toString() {
        return "Person [name=" + name + ", age=" + age + "]";
    }
    @Override
    public int compareTo(Person p) {
        //按照年龄
/*        if(this.age>=p.age) {
            return 1;
        }else {
            return -1;
        }
*/        
        //按照姓名
        int compareTo = this.name.compareTo(p.name);
        return compareTo;
    }
}

 

   ·HashSet和TreeSet的应用

import java.util.*;
class Demo6 {
    public static void main(String[] args) {
        //随机生成5个互不相同的1--10之间的随机数  Set，HashSet
        Random r = new Random();
        HashSet hs =new HashSet();

        while(hs.size()<5){
           int num = r.nextInt(10)+1;
           hs.add(num);
        }
        System.out.println(hs);
    }
}

import java.util.*;
class Demo7 {
    public static void main(String[] args) {
        String str="12,4,56,123,67";//对字符串中的数值进行排序
        String[] arr=str.split(",");
        TreeSet ts = new TreeSet();
        for(int i=0;i<arr.length;i++){
            //ts.add(arr[i);            //    不能用这个，这个使用的是字符串中的compareTo,是字典顺序    
           ts.add(Integer.parseInt(arr[i]));
        }
        System.out.println(ts);
    }
}

   ·Comparator接口   compareTo()方法

 /*
 TreeSet: 具备Set的基本特征，还可以进行排序

                TreeSet排序是调用添加到集合中的对象的compareTo()方法确定下来谁大谁小
                才能排序的，所以如果添加到集合中的对象所属的类没有实现compareTo方法，TreeSet是不能排序
                底层数据结构使用的是二叉树(红黑树)
                排序的第二种方式：Comparator  int compare(Object obj1,Object obj2)

                当类本身具备的排序方式不能满足我们的需求时，那么使用自定义比较方法

package com.zqf;
import java.util.*;
public class Test{
    public static void main(String[] args) {
        //Set<Person> set=new TreeSet<Person>((l1,l2) -> l1.getName().compareTo(l2.getName()));　　//按姓名排序
        Set<Person> set=new TreeSet<Person>((l1,l2) -> l1.getAge()-l2.getAge());　　　　　　　　　　　//按年龄排序
        
        set.add(new Person("zhangsan",12));
        set.add(new Person("lisi",14));
        set.add(new Person("wanger",13));
        System.out.println(set);
    }
}
class Person {
    private String name;
    private int age;
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    public int getAge() {
        return age;
    }
    public void setAge(int age) {
        this.age = age;
    }
    public Person(String name, int age) {
        super();
        this.name = name;
        this.age = age;
    }
    public Person() {
        super();
    }
    @Override
    public String toString() {
        return "Person [name=" + name + ", age=" + age + "]";
    }
    
    
}

 

 

 

  ·泛型

　　通过<引用数据类型>指定集合中存储的对象的类型，在程序编译时就会检查集合中存储的数据是不是泛型指定的类型
      如果不是，那么编译不通过，从而把运行时期的问题转移到了编译时期，是程序更安全，提高了程序的安全性

import java.util.*;
class Demo10 {
    public static void main(String[] args) 
    {   //使用了泛型，只要编译通过，运行就不会出问题
        //ArrayList<E>
        ArrayList<String> list=new ArrayList<>();//通过泛型限定集合中存储数据的类型，使程序更安全

        list.add("66");
        list.add("77");
        list.add("44");
        //list.add(55);

        Iterator<String> ite = list.iterator();
        while(ite.hasNext()){
            //Object obj = ite.next();
            //String str=(String)obj;
            String str = ite.next();
            System.out.println(Integer.parseInt(str));
        }
    }
}

 day15

   ·泛型

在类上定义泛型
 　　class Demo<T>
　　 {
　　 }
　　 Demo<String > demo=new Demo<String>(); //在创建类的对象时才能确定泛型，泛型属于非静态类型
在方法上定义泛型
 　　class Test<E>{
  　　public void ff(E e){
 　　 }
  　　public <E> void show(E e){
 　　 }
 　　 public static <T> void fun(T t){  //静态方法只能自己用泛型
 　　 }
 　　}

在接口上定义泛型
　　 interface inter<E>{
 　　 void ff(E e);
 　　}

   ·泛型中的通配符：？

//通配符:  ?
import java.util.*;
class Demo3 {
    public static void main(String[] args) {
        ArrayList<String> list1=new ArrayList<>();
        list1.add("java");
        list1.add("mysql");
        list1.add("hadopp");

        //bianLi(list1);
        dieDai(list1);

        ArrayList<Integer> list2=new ArrayList<>();
        list2.add(77);
        list2.add(88);
        list2.add(99);

        //bianLi(list2);
        dieDai(list2);
    }
    //通配符: ?  表示什么类型都行
    public static  void dieDai(Collection<?> coll){
         Iterator<?> ite=coll.iterator();
         while(ite.hasNext()){
             //? obj=ite.next();非法的表达式开始
             System.out.println(ite.next());
         }
    }

    //通用的遍历的方法:泛型方法
    public static <E> void bianLi(Collection<E> coll){
         Iterator<E> ite=coll.iterator();
         while(ite.hasNext()){
            E obj=ite.next();

            System.out.println(obj);
         }
    }
}

 

   ·泛型限定

泛型限定:  ? extends E:限定了上限（E类型或其子类类型）  ? super E:限定了下限，E类型或其父类类型

//泛型限定:  ? extends E:限定了上限（E类型或其子类类型）  ? super E:限定了下限，E类型或其父类类型
import java.util.*;
class Person implements Comparable<Person>{
    private String name;
    private int  age;

    Person(){}

    Person(String name,int age){
      this.name=name;
      this.age=age;
    }
    public int compareTo(Person ren){
        return this.age-ren.age;
    }
    public String getName(){
       return this.name;
    }
    public String toString(){
      return name+","+age;
    }
}
class ComByName implements Comparator<Person>{
    public int compare(Person p1,Person p2){
        return p1.getName().compareTo(p2.getName());
    }
}
class Student extends Person{
     Student(){}
     Student(String name,int age){
       super(name,age);
     }
}
class Worker extends Person{
    Worker(){}
    Worker(String name,int age){
       super(name,age);
    }
}
class Demo4 {
    public static void main(String[] args) {
        ArrayList<Student>  list=new ArrayList<>();

        list.add(new Student("lisi",20));
        list.add(new Student("wangwu",18));
        list.add(new Student("amen",28));

        dieDai(list);

        ArrayList<Worker>  list2=new ArrayList<>();

        list2.add(new Worker("zhangsi",29));
        list2.add(new Worker("zhaoliu",38));
        list2.add(new Worker("liming",18));

        dieDai(list2);

        ArrayList<Integer>  list3=new ArrayList<>();
        list3.add(66);
        list3.add(666);
        list3.add(6666);
        
        //dieDai(list3);
    }
    public static  void dieDai(Collection<? extends Person> coll)//集合中对象的类型必须是Person或Person的子类类型
    {
         Iterator<?> ite=coll.iterator();
         while(ite.hasNext()){
             System.out.println(ite.next());
         }
    }
}

 

   ·Map接口   HashMap类

Map<k,v>接口
 　　是一个单独的接口，属于集合，但没有继承Collection，存储的是简直对，一对一对的存，键不能重复，值可以重复
 　　（当存在映射关系的情况下，使用Map）

Map<String,String> m = new HashMap<>();
m.put("name","lisi");
m.remove("name")
m.get("name");
m.size()
m.isEmpty()
m.containsKey("name")
m.containsValue("lisi")
Collection<String> v = m.values()
HashMap:保证键唯一，原理和HashSet一样 
TreeMap:根据键排序，原理和TreeSet一样

/*
Map<K,V>:是一个单独的接口，属于集合，但没有继承Collection,存储的是键值对儿，一对一对的存，键不能重复

    HashMap:

    TreeMap:

Map接口中定义的功能：

添加:
 V put(K key, V value) 
 void putAll(Map<? extends K,? extends V> m)  //addAll()
 
删除:
 V remove(Object key) 
 void clear() 
         
获取：
  V get(Object key) 

  Set<K> keySet() 
  Set<Map.Entry<K,V>> entrySet() 

  int size() 
  Collection<V> values() 
判断:
   boolean isEmpty() 
   boolean containsKey(Object key) 
   boolean containsValue(Object value)
*/
import java.util.*;
class Demo6{
    public static void main(String[] args) {
        Map<String,String>  map = new HashMap<>();
        /*
        //String v=map.put("aa","lisi");//返回的是被覆盖的键值对的值
        //sop(v);//null

        String vv=map.put("aa","zhangsan");//把上一个同名的键值对覆盖掉
        //sop(vv);//lisi

        */
        //键不能重复
        map.put("name","zhangsan");
        map.put("age","20");
        map.put("address","上海");

        //map.remove("address");//根据键删除键值对
        //map.clear();

        //sop(map.size());//得到集合中键值对儿的对儿数
        //sop(map.isEmpty());

        // Collection<V> values()  得到集合中所有的值
        Collection<String>  vs = map.values();

        Iterator<String> ite=vs.iterator();
        while(ite.hasNext()){
          sop(ite.next());
        }
        // V get(Object key) 根据键获取值
        String zhi = map.get("age");
        sop(zhi);

        //boolean containsKey(Object key) 判断集合是否包含某个键
         boolean b = map.containsKey("names");
         sop(b);

        //boolean containsValue(Object value)判断集合是否包含某个值
         b=map.containsValue("上海");
         sop(b);
    }
    public static <E> void sop(E obj){
        System.out.println(obj);
    }
}

 

   ·Map接口   两种遍历方法

/*
Set<K> keySet() :   取到所有的键存到一个Set集合，并返回该集合对象，因为Set有迭代器，所以得到迭代器，每次迭代出来的是一个键
                    根据键获取值


Set<Map.Entry<K,V>> entrySet() : 得到每个键值对儿对应一个Map.Entry(映射关系)类型的值，存到一个Set集合中，Set有迭代器
                                 没次迭代出来的是一个Map.Entry(映射关系)类型的值，这个值中既包括键，也包括值
                                 Entry是定义在Map内部的静态成员，Entry是对Map集合内部的键值对的映射关系的描述，所以定义在Map
                                 的内部

*/
import java.util.*;
class Demo7{
    public static void main(String[] args) {
        //Map没有迭代器
        //Map 实现遍历的方法: Set<K> keySet()   Set<Map.Entry<K,V>> entrySet() 

        Map<String,String> map = new HashMap<>();

        map.put("name","zhangsan");
        map.put("age","20");
        map.put("address","上海");

       Set<Map.Entry<String,String>> en= map.entrySet();

       Iterator<Map.Entry<String,String>> ite=en.iterator();
       while(ite.hasNext()){
            Map.Entry<String,String> e=ite.next();
            String jian=e.getKey();
            String zhi=e.getValue();

            System.out.println(jian+"="+zhi);
        } 
       /*
        Set<String> keys=map.keySet();
        Iterator<String> ite=keys.iterator();

        while(ite.hasNext()){
            String key=ite.next();
            String value=map.get(key);
            System.out.println(key+"="+value);
        }
       */        
    }
}

   ·HashMap详解

底层使用数据结构是哈希表，HashSet:保证对象不重复
保证键不重复：int hashCode()    boolean equals(Object obj)

 import java.util.*;
 class Student implements Comparable<Student>{
     private String name;
     private int age;
     Student(){}
     Student(String name,int age){
       this.name=name;
       this.age=age;
     }
     public int compareTo(Student stu){
         int num=this.age-stu.age;
         return num==0?this.name.compareTo(stu.name):num;
     }
     
     public int hashCode(){
         return name.hashCode()+age*56;
     }
     public boolean equals(Object obj){
        if(!(obj instanceof Student))
            throw new ClassCastException("类型错误");

        Student stu = (Student)obj;

        return this.name.equals(stu.name)&&this.age==stu.age;
     }

     public String getName(){
        return name;
     }
     public int getAge(){
        return age;
     }
     public String toString(){
       return name+","+age;
     } 
 }
class Demo8 {
    public static void main(String[] args) {
        //什么情况下使用Map：当存在映射关系的时候，每个学生有一个住址

        //底层数据结构是哈希表，HashSet：保证对象不重复
        //保证键唯一：int hashCode()  boolean equals(Object obj) 
        HashMap<Student,String> map = new HashMap<>();

        //姓名，年龄相同认为是同一个对象
        map.put(new Student("zhangsan",28),"北京");
        map.put(new Student("wangwu",18),"上海");
        map.put(new Student("lisi",38),"深圳");
        map.put(new Student("lisi",38),"纽约");

        Set<Student> keys = map.keySet();
        Iterator<Student> ite=keys.iterator();

        while(ite.hasNext()){
            Student stu =ite.next();

            String address=map.get(stu);

            sop(stu+"="+address);
        }
    }
    public static void sop(Object obj){
      System.out.println(obj);
    }
}

 

   ·Map接口   TreeMap类

TreeMap,按照键的顺序排序，方法与TreeSet相同

import java.util.*;
//自定义比较方式
class ComByName implements Comparator<Student>{
    public int compare(Student stu1,Student stu2 ){
         int num = stu1.getName().compareTo(stu2.getName());

         return  num==0?stu1.getAge()-stu2.getAge():num;
    }
}
class Demo9 {
    public static void main(String[] args) {
        //底层是二叉树    TreeSet:add
        //根据键排序,无序
        ComByName cn = new ComByName();
        TreeMap<Student,String> map = new TreeMap<>(cn);
        
        //使用put添加键值对的时候就排序了
        map.put(new Student("zhangsan",28),"北京");
        map.put(new Student("wangwu",18),"上海");
        map.put(new Student("lisi",38),"深圳");
        map.put(new Student("lisi",38),"纽约");


        Set<Map.Entry<Student,String>>  en = map.entrySet();
        Iterator<Map.Entry<Student,String>> ite=en.iterator();

        while(ite.hasNext()){
             Map.Entry<Student,String> e=ite.next();
             Student key=e.getKey();
             String value=e.getValue();

             sop(key+"="+value);
        }
    }
    public static void sop(Object obj){
      System.out.println(obj);
    }
}

    ·Map的运用

import java.util.*;
class Demo10 {
    public static void main(String[] args) {
        //每个班级对应多个学生

        HashMap<String,List<Student>> school=new HashMap<>();

        List<Student> list1=new ArrayList<>();
        list1.add(new Student("lisi",20));
        list1.add(new Student("wangsi",28));
        list1.add(new Student("zhaosi",19));

        List<Student> list2=new ArrayList<>();
        list2.add(new Student("lisi2",22));
        list2.add(new Student("wangsi2",25));
        list2.add(new Student("zhaosi2",18));

        school.put("gp1905",list1);
        school.put("gp1904",list2);

        Set<String> keys = school.keySet();

        Iterator<String> ite=keys.iterator();
        while(ite.hasNext()){
             String banji = ite.next();
             sop("班级名称:"+banji);
             sop("班级人员有:");

             List<Student>  stus=school.get(banji);

             //sop(stus);
             
             Iterator<Student> it=stus.iterator();
             while(it.hasNext()){
                  Student ss=it.next();
                  sop(ss);
             }
        }
    }
    public static void sop(Object obj){
      System.out.println(obj);
    }
}

   ·数组转集合，数组转字符串

数组转字符串：Arrays.toString()
数组转集合：Arrays.asList()

import java.util.*;
class Demo12 {
    public static void main(String[] args) {
        
        //数组转字符串
        int[] arr={12,34,56,67,23,8};
        String str = Arrays.toString(arr);
        sop(str);
        
        //static <T> List<T> asList(T... a)  

        //数组转集合：使用集合的方法
        String[] arr2={"hello","java","mysql","hadoop"};
        List<String> list = Arrays.asList(arr2);
        //sop(list);
        //数组转成的集合不能执行添加，删除，否则异常
        //list.add("h5");//UnsupportedOperationException

        boolean b = list.contains("java");
        sop(b);

        int[] c={3,4,5,6};
        List<int[]> jihe = Arrays.asList(c); //集合中存的是引用类型的数据，数组是引用数据类型，所以把整个数组存到集合中
        sop(jihe.get(0)[0]);//  1
    }
    public static void sop(Object obj){
        System.out.println(obj);
    }
}

   ·集合转数组

集合转数组:<T> T[] toArray(T[] t)

import java.util.*;
class Demo13 {
    public static void main(String[] args) {
        
        //集合转数组  <T> T[] toArray(T[] a)  
        List<String> list= new ArrayList<>();

        list.add("hello");
        list.add("java");
        list.add("mysql");

        //给定的数组的长度大于集合中数据的个数，使用给定的
        //给定的数组的长度小于集合中数据的个数，不使用给定的
        //最好给定义一个长度和集合相同的数组
        String[] arr = list.toArray(new String[list.size()]);
        sop(arr.length);

        for(int i=0;i<arr.length;i++){
           sop(arr[i]);
        }
    }
    public static void sop(Object obj){
        System.out.println(obj);
    }
}

   ·增强for循环

 for(数据类型  变量名:被遍历的Collection集合或数组){}                

可用来遍历collection集合和数组

/*
增强的for循环
    for(数据类型  变量名:被遍历的Collection集合或数组){   }
*/
import java.util.*;
class Demo14 {
    public static void main(String[] args) {
        int[] arr={23,4,67,12,78};

        for(int num:arr){
            sop(num);
        }

        List<String> list= new ArrayList<>();

        list.add("hello");
        list.add("java");
        list.add("mysql");

        for(String str:list){
           sop(str.toUpperCase());
        }

        Map<String,String> lm = new HashMap<>();
        lm.put("name","lisi");
        lm.put("age","20");
        lm.put("weight","200");

        Set<String> keys = lm.keySet();
        for(String key:keys){
             String v = lm.get(key);
             sop(key+"="+v);
        }

        Set<Map.Entry<String,String>> en=lm.entrySet();
        for(Map.Entry<String,String> me:en){
           String key = me.getKey();
           String value=me.getValue();

           sop(key+"="+value);
        }        
    }
    public static void sop(Object obj){
        System.out.println(obj);
    }
}

 day16

   ·Collections集合工具类

 Collections集合工具类
 Collections.sort(list);   //排序
 Collections.reverseOrder()
 Collections.reverse()
 Collections.max()
 Collections.min()

List<Integer> list = new ArrayList<>();
List<Integer> dest = new ArrayList<>();

// 1、向集合中添加元素
Collections.addAll(list, 10, 20, 30, 10, 0, 9, 8, 11, 17, 21);
Collections.addAll(dest, 0,0,0,0,0,0,0,0,0,00,0,0,0,0,0,0,0,0,0);

// 2、找出一个集合中的最大值
System.out.println(Collections.max(list));

// 3、找出一个集合中的最小值
System.out.println(Collections.min(list));

// 4、将集合中的元素进行随机排列
Collections.shuffle(list);

// 5、排序
// 使用这个方法进行排序的时候，需要保证集合中的元素对应的类实现Comparable接口
Collections.sort(list);    
// 使用指定的排序规则，对集合中的数据进行排序
Collections.sort(list, (e1, e2) -> e2 - e1);

// 6、元素拷贝
Collections.copy(dest, list);

// 7、翻转
Collections.reverse(dest);

// 8、交换两个下标的元素
Collections.swap(list, 0, 1);

// 9、用指定的元素填充满集合
Collections.fill(dest, 1);

// 10、将指定的集合转成线程安全的集合。
// Collection Collections.synchronizedCollection(list);
// List Collections.synchronizedList(list);
// Set Collections.synchronizedSet(s);
// Map Collections.synchronizedMap(m);

System.out.println(dest);

 

   ·可变参数

　　简化书写，原理是数组，注意：可变参数必须位于参数列表的最后。
 　　fun(1,2,3,53,65,3);
　　 fun(int ... a) 

/*
可变参数：简化书写,原理是数组，注意：可变参数必须位于参数列表的最后
*/
class Demo2 {
    public static void main(String[] args) {

         //int[] b={12,34,45,23,5,67};
         int he = add(12,34,45,23,5,67,12,3);
         sop(he);
    }

    public static int add(int ... arr){
        int sum=0;
        for(int i=0;i<arr.length;i++){
           sum=sum+arr[i];
        }
        return sum;
    }
    public static void sop(Object obj){
        System.out.println(obj);
    }
}

   ·properties类

 Map的子类，属于集合，存储的键和值必须是String类型的，适合存储属性  （了解即可）
 得到所有的键：stringPropertyNames();
 存放键值对：   setProperty(String key,String value);
 根据键获取值：getProperty(String key);

import java.util.*;
class Demo3 {
    public static void main(String[] args) {
        //  Properties: 是一个Map集合类，存储的键和值必须是String类型的，适合存储属性

        //得到系统属性
        Properties pro =  System.getProperties();
        sop(pro);

        //得到集合中所有的键  keySet()
        /*
        Set<String> keys= pro.stringPropertyNames();
        for(String key:keys){
            //根据键获取值
            String value = pro.getProperty(key);
            sop(key+"="+value);
        }*/
        pro.setProperty("user.country","china");//put

        Set<String> keys= pro.stringPropertyNames();
        for(String key:keys){
            //根据键获取值
            String value = pro.getProperty(key);
            sop(key+"="+value);
        }
    }

    public static void sop(Object obj){
        System.out.println(obj);
    }
}

// 1、实例化一个Properties对象
Properties properties = new Properties();

// 2、加载某一个.properties文件，读取这个文件中的信息
try {
    properties.load(new FileReader("file\\info.properties"));
} catch (IOException e) {
    e.printStackTrace();
}

// 3、获取
String name = properties.getProperty("name");
System.out.println(name);

String height = properties.getProperty("height", "111");
System.out.println(height);

// 4、修改、添加
properties.setProperty("name", "xiaohei");
properties.setProperty("weight", "123");


// 5、对Properties进行操作，结束之后，一定要同步到文件中，否则这些数据只能存在于内存
try {
    properties.store(new FileWriter("file\\info.properties"), "hello world");
} catch (IOException e) {
    // TODO Auto-generated catch block
    e.printStackTrace();
}

// 6、遍历
properties.forEach((k, v) -> System.out.println(k + " : " + v));

 

import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;
import java.util.Properties;

public class Test1 {
    public static void main(String[] args) throws IOException {
        Properties pro = new Properties();
        FileInputStream fis = new FileInputStream("a.properties");
        FileOutputStream fos  = new FileOutputStream("a.properties");

        pro.load(fis);

    pro.setProperty("name","lisi");

    pro.store(fos,"ok");

    fis.close();
        fos.close();
    }
}

 

   ·静态导入

　　例：  import static java.util.Ararys.*;
             类名相同，通过包名区分
  　　   方法名相同，通过类名区分

import java.util.*;
import static java.util.Arrays.*;//静态导入
class Demo4 //toString(){
    public static void main(String[] args) {
        int[] arr={12,34,45,56,67,78};
        sort(arr);
        int index =binarySearch(arr,56);
        String str=java.util.Arrays.toString(arr);//方法名相同，类名不能省略,类名相同，通过包名区分
        System.out.println(str);
    }
}
class Arrays {}

   ·IO流（Input ,Output）

输入输出流：用来实现设备之间的数据传输

 分类： 按照方向分类：输入流，输出流（相对于内存） 对内存是进数据就是输入流，出数据就是输出流保存文件是输出，打开是输入
  　　    按照操作的数据分类：
  　　　　 字节流：可以操作任何类型的数据，文本，图片，视频，音频
  　　　　 字符流：只能操作文本数据，因为字符涉及到编码，在字节流的基础上加入了编码方便操作文本数据。
    　　　　　　ASCII  GBK   utf-8

字节流：
　　InputStream 字节输入流父类
　　OutputStream 字节输出流父类

字符流
　　Reader   字符输入流父类
　　Writer     字符输出流父类 

　　　　　　　　　　　　　　　　　　记住：Writer输出流可以对文本写入，Reader输入流对文本读出

输入设备：键盘，文件，网络，内存

输出设备：控制台，文件，网络，内存
以硬盘设备为例

 

   ·向文本写入数据

 （从内存中读取数据）

import java.io.*;
class Demo5 {
    public static void main(String[] args) throws IOException{
        //向文本文件写入数据
        //因为是文本文件所以使用字符流，又因为是写入所以使用字符输出流(Writer),又因为是文件(硬盘),
         //所以使用 Writer的可以操作文件的子类FileWriter

        //1:创建文件输出流对象和文件相关联  FileWriter(String fileName) 
        //文件可以事先不存在，系统会自动创建
        FileWriter fw = new FileWriter("temp.txt");

        //2：使用输出流对象向与其关联的文件中写入数据
        fw.write("abc");//写入到内部的数组了，因为需要查表
        
        //fw.flush();//把内部数组的数据刷到文件中

        fw.write("def");//刷完之后还可以继续写

        //释放资源：流对象
        fw.close();//关闭流的同时会刷新流

        //fw.write("ww");//流已关闭，不能继续写入数据
    }
}

import java.io.*;
class Demo6 {
    public static void main(String[] args) {
        FileWriter fw=null;
        try{
            fw = new FileWriter("temp.txt");//系统找不到指定的路径
            fw.write("abcdef"); 
        }catch(IOException e){
            e.printStackTrace();
        }finally{
           try{
               if(fw!=null)    //这个意思是当文件存在时，可以关闭，否则会报空指针异常
                   fw.close();//null.close();
           }catch(IOException ee){
               throw new RuntimeException("字符输出流关闭失败");
           }    
        }
    }
}

   ·文件的续写

import java.io.*;
class Demo7 {
    public static void main(String[] args) throws IOException{
          String SEPARATOR=System.getProperty("line.separator");

          //文件的续写：默认都是从文件的末尾写入数据
          FileWriter fw= new FileWriter("temp.txt",true);
          fw.write("hello");
          fw.write(SEPARATOR);
          fw.write("world");
          fw.close();
    }
}

   ·读取文本文件数据的两种方式

　　使用字符时，num=fr.read();   num表示每一个字符的编码，当num到最后时，变成-1

　　使用数组时，char[] arr=new char[1024] ; num=fr.read(arr),   num此时表示字符的个数，当到最后时，变成-1

　　使用字符

import java.io.*;
class Demo8 {
    public static void main(String[] args) throws IOException{
        //从文本文件中读取数据  1.先确定是字符流还是字节流，2再确定用输入流还是输出流，3最后确定什么设备

        //因为是文本文件，所以使用字符流，又因为是读取所以使用输入流，因为是文件所以使用Reader的可以操作文件的子类FileReader

        //1：创建文件输入流对象和文件相关联
        //文件需要事先存在
        FileReader fr =new FileReader("temp.txt");

        //2:使用输入流对象读取数据

        //int read()  读一个字符 效率低

        int num;
        while((num=fr.read())!=-1){
            System.out.print((char)num);
        }
        fr.close();
    }
}

　　使用数组

import java.io.*;
class Demo9 {
    public static void main(String[] args)throws IOException {
        FileReader fr =new FileReader("temp.txt");

        char[] arr=new char[1024];
        int num;

        while((num=fr.read(arr))!=-1){
           System.out.print(new String(arr,0,num));
        }

        fr.close();
    }
}

   ·文本复制

import java.io.*;
class Demo10 {
    public static void main(String[] args) throws IOException {
        //实现复制一个文本文件，Demo3.java, 读取Demo3.java写入到一个新的文件

        FileReader fr=new FileReader("Demo3.java");
        FileWriter fw = new FileWriter("Demo3_copy.java");
        int num;

        while((num=fr.read())!=-1){
            fw.write(num);
        }
        
        fr.close();
        fw.close();
    }
}

import java.io.*;
class Demo11{
    public static void main(String[] args) {
        FileReader fr = null;
        FileWriter fw = null;
        try{
             fr=new FileReader("Demo5.java");
             fw=new FileWriter("Demo5_copy.java");

             char[] arr=new char[1024];
             int num;
             while((num=fr.read(arr))!=-1){
                 fw.write(arr,0,num);
             }    
        }catch (IOException e){
             e.printStackTrace();

        }finally{
            if(fr!=null)
               try{
                  fr.close();
               }
               catch (IOException ee){
                   throw new RuntimeException("字符读取流关闭失败");
               }

           if(fw!=null)
               try{
                  fw.close();
               }
               catch (IOException ee){
                   throw new RuntimeException("字符输出流关闭失败");
               }
        }
    }
}

   ·文件夹的复制

package com.zqf;

/**
 * 
 * 复制文件夹d:/java下面所有文件和子文件夹内容到d:/java2。
    提示：涉及单个文件复制、目录的创建、递归的使用
 */
import java.io.BufferedInputStream;
import java.io.BufferedOutputStream;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
import java.util.Scanner;

public class Test{
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        System.out.print("From：");
        String sourcePath = scanner.nextLine();
        System.out.print("To：");
        String newPath = scanner.nextLine();
        copyDir(sourcePath, newPath);
    }
    
    //文件夹的拷贝
    public static void copyDir(String sourcePath, String newPath) {
        File start = new File(sourcePath);
        File end = new File(newPath);
        String[] filePath = start.list();       //获取该文件夹下的所有文件以及目录的名字
        if(!end.exists()) {
            end.mkdir();
        }
        for(String temp:filePath) {
            //查看其数组中每一个是文件还是文件夹
            if(new File(sourcePath+File.separator+temp).isDirectory()) {
                //为文件夹，进行递归
                copyDir(sourcePath+File.separator+temp, newPath+File.separator+temp);
            }else {
                //为文件则进行拷贝
                copyFile(sourcePath+File.separator+temp, newPath+File.separator+temp);
            }
        }
    }
    
    //文件的拷贝
    public static void copyFile(String sourcePath, String newPath) {
        File start = new File(sourcePath);
        File end = new File(newPath);
        try(BufferedInputStream bis=new BufferedInputStream(new FileInputStream(start));
            BufferedOutputStream bos=new BufferedOutputStream(new FileOutputStream(end))) {
            int len = 0;
            byte[] flush = new byte[1024];
            while((len=bis.read(flush)) != -1) {
                bos.write(flush, 0, len);
            }
            bos.flush();
        }catch(FileNotFoundException e) {
            e.printStackTrace();
        }catch(IOException e) {
            e.printStackTrace();
        }
    }
}

 

 

 

day17

   ·字符缓冲流

字符缓冲流：只是用来提高读或写的效率
    缓冲流本身不具备读或写的功能
    使用缓冲流必须结合着读流或写流

纯粹来提高效率的

字符输入缓冲流：BufferedReader 就只有一个特殊的方法，String readLine();   读一行，返回的一行字符不包括换行符

字符输出缓冲流：BufferedWriter 就只有一个特殊的方法，void newLine()   换行

    ·字符缓冲流文本写入数据-BufferedWriter

import java.io.*;
class Demo1 {
    public static void main(String[] args)throws IOException{
        //使用缓冲流向文本文件中写入数据  FileWriter（具备写入功能的流类）

        //1.因为缓冲流不具备写入的功能，所以需要先创建FileWriter对象
        FileWriter fw = new FileWriter("tt.txt");

        //2.为了提高FileWriter对象fw 写入的效率，创建输出缓冲流对象
        //BufferedWriter(Writer out) 
        BufferedWriter bw=new BufferedWriter(fw);

        for(int i=1;i<=5;i++){
           bw.write("java"+i);
           bw.newLine();//跨平台的写入换行符  
           bw.flush();
        }
        bw.close();
    }
    public static void sop(Object obj){
        System.out.println(obj);
    }
}

   ·字符缓冲读取文本数据-BufferReader

import java.io.*;
class Demo2 {
    public static void main(String[] args)throws IOException{
        //使用缓冲流读取文本文件

        //1.因为缓冲流不具备读取的功能，所以需要先创建FileReader对象
        FileReader fr = new FileReader("tt.txt");

        //2.为了提高FileReader对象fr 读的效率，创建输入缓冲流对象
        //  BufferedReader(Reader in) 
        BufferedReader br=new BufferedReader(fr);
        String line = null;

        while((line=br.readLine())!=null){//返回的一行字符不包括换行符
        
              System.out.println(line);
        }

        br.close();//关闭缓冲流就是关闭文件读取流
    }
}

 

   ·字符缓冲流文件的复制

import java.io.*;
class Demo5 {
    public static void main(String[] args){
        //使用缓冲流实现文件的复制
        BufferedReader br=null;
        BufferedWriter bw = null;
        try{
               br=new BufferedReader(new FileReader("Demo3.java"));
               bw=new BufferedWriter(new FileWriter("Demo3_copy.java"));

               String line=null;
               while((line=br.readLine())!=null){
                  bw.write(line);
                  bw.newLine();//加入换行
               }    
        }catch (IOException e){
            e.printStackTrace();
        }finally{
            try{
                if(br!=null)
                    br.close();
            }
            catch (IOException ee){
                throw new RuntimeException("文件读取流关闭失败");
            }
            try{
                if(bw!=null)
                    bw.close();
            }
            catch (IOException ee){
                throw new RuntimeException("文件写入流关闭失败");
            }
        }
    }
    public static void sop(Object obj){
        System.out.println(obj);
    }
}

   ·字节流

字节流：可以操作任何类型的数据
InputStream
OutputStream

import java.io.*;
/*
字节流：可以操作任何类型的数据
InputStream
OutputStream
*/
class Demo8 {
    public static void main(String[] args)throws IOException{
        //writeFile();
        //readFile();
        //readFile2();
        fun();
    }
    public static void fun()throws IOException{
         //int available() 
         FileInputStream fis = new FileInputStream("temp.txt");
         int n = fis.available();//得到总的字节数 3
         byte[] arr=new byte[n];//创建一个和文件大小相同的字节数组，不用循环读取了
         int num = fis.read(arr);
         sop(new String(arr,0,num));
    }

    public static void readFile2()throws IOException{
       //int read(byte[] b) 返回的是读取的字节的个数
       
       FileInputStream fis = new FileInputStream("temp.txt");
       int num;
       byte[] arr=new byte[1024];

       while((num=fis.read(arr))!=-1){
           System.out.println(new String(arr,0,num));    
        }
       fis.close();
    }

    //从文件中读取数据
    public static void readFile()throws IOException{
       FileInputStream fis = new FileInputStream("temp.txt");
       //int read()  一次读一个字节
       int num;
       while((num=fis.read())!=-1){
         System.out.print((char)num);
       }
       fis.close();    
    }

    //向文件中写入数据
    public static void writeFile()throws IOException{
       FileOutputStream  fos = new FileOutputStream("temp.txt");
       fos.write("abc".getBytes());//byte[] getBytes()
       fos.close();
    }
    public static void sop(Object obj){
        System.out.println(obj);
    }
}

   ·字节流复制文件

import java.io.*;
class Demo9 {
    public static void main(String[] args)throws IOException{
        //复制一张图片
        FileInputStream fis =new FileInputStream("m.jpg");
        FileOutputStream fos =new FileOutputStream("m_copy.jpg");

        int num;
        while((num=fis.read())!=-1){
           fos.write(num);
        }

        fis.close();
        fos.close();
    }
    public static void sop(Object obj){
        System.out.println(obj);
    }
}

   ·缓冲字节流

import java.io.*;
class Demo10 {
    public static void main(String[] args){
        //使用字节缓冲流实现图片复制
        BufferedInputStream bis = null;
        BufferedOutputStream bos =null;
        try{
            bis = new BufferedInputStream(new FileInputStream("m.jpg"));
            bos= new BufferedOutputStream(new FileOutputStream("mm.jpg"));

            byte[] arr=new byte[1024];
            int num=0;

            while((num=bis.read(arr))!=-1){
               bos.write(arr,0,num);
            }    
        }catch (IOException e){
            e.printStackTrace();
        }finally{
            if(bis!=null)
                try{
                    bis.close();
                }
                catch (IOException ee){
                    throw new RuntimeException("字节缓冲读取流关闭失败");
                }
            if(bos!=null)
                try{
                    bos.close();
                }
                catch (IOException ee){
                    throw new RuntimeException("字节缓冲写入流关闭失败");
                }
        }
    }
    public static void sop(Object obj){
        System.out.println(obj);
    }
}

    ·转换流

import java.io.*;

/*

使用System.in实现一次读一行的功能，代码实现很麻烦

代码实现和BufferedReader的readLine()方法的代码实现类似

能不能使用 BufferedReader的readLine()方法实现键盘输入

System.in        InputStream  字节输入流

BufferedReader   Reader       字符输入流


转换流：把字节流转成字符流

InputStreamReader：是从字节流到字符流的桥

OutputStreamWriter:
*/
class Demo12 {
    public static void main(String[] args) throws IOException{
        InputStream  in = System.in;//字节输入流

        InputStreamReader ir = new InputStreamReader(in);//转换流

        BufferedReader  br = new BufferedReader(ir);

        PrintStream  out=System.out;//字节输出流

        OutputStreamWriter os=new OutputStreamWriter(out);

        BufferedWriter bw = new BufferedWriter(os);

        
        String line=null;

        while((line=br.readLine())!=null)//读键盘读不到null
        {
             if("over".equals(line))
                 break;
             bw.write(line);
             bw.newLine();
             bw.flush();
             //System.out.println(line);
        }
       br.close();
    }
}

day18

   ·File文件流

把文件和文件夹面向对象的描述类
  createNewFile()
  mkDir()
  isFile()
  isDirectory()
  getName()
  getPath()
  getAbsolutePath()
  lastModified()
  File[] listFiles()
  delete()

import java.io.*;
import java.util.*;
import java.text.*;
class Demo2 {
    public static void main(String[] args)throws IOException {
        // File: 把文件和文件夹面向对象的描述类

        //File(String pathname) 
        File f1=new File("e:\\1905\\day18\\Demo1.java");


        //File(String parent, String child) 
        File f2=new File("e:\\1905\\day18","Demo1.java");

        //File(File parent, String child) 
        File ff =new File("e:\\1905\\day18");
        File f3=new File(ff,"Demo1.java");


        //method1();
        method2();
    }
    public static void method2(){
        File file = new File("test.txt");

        sop(file.getName());//得到文件名
        sop(file.getPath());
        sop(file.getParent());
        sop(file.getAbsolutePath());//得到绝对路径（全路径）

        //long lastModified()  
        sop(new SimpleDateFormat("yyyy-MM-dd HH:mm:ss").format(new Date(file.lastModified())));//得到的是最后一次修改时间

        sop(file.delete());
    }

    public static void method1()throws IOException{
        File file1 = new File("f:\\hehe.txt");
        File file = new File("f:\\haha");

        if(!file.exists())
            //file.createNewFile();//创建文件
            file.mkdir();//创建文件夹

       sop(file1.isFile());//判断是不是文件 true

       sop(file.isDirectory());//判断是不是文件夹

       sop(file.isHidden());
    }
    public static void sop(Object obj){
       System.out.println(obj);
    }
}

   ·获取文件夹中的文件目录：String[] list()     File[] listFiles()

import java.io.*;
class Demo3 {
    public static void main(String[] args) throws IOException {

        //String[] list()
        
        File file=new File("e:\\1905\\day17");

        /*
        String[] arr = file.list();//得到某个文件夹下的所有的目录内容
        for(String str:arr){
           sop(str);
        }*/

        //File[] listFiles() 
        
        File[] arr=file.listFiles();//得到某个文件夹下的所有的带绝对路径的内容
        for(File ff:arr){
            sop(ff);
        }

        //File[] listRoots() 
        /*
        File[] arr = File.listRoots();//
        for(File file:arr){
          sop(file);
        }*/
    }
    public static void sop(Object obj){
       System.out.println(obj);
    }
}

   ·以...结尾的文件判断

import java.io.*;
/*
class FilterByName implements FilenameFilter{
    private String ends;

    FilterByName(){}

    FilterByName(String ends){
       this.ends=ends;
    }
    public boolean accept(File dir, String name)  {
         if(name.endsWith(ends))
              return true;
         else
             return false;
    }
}*/
class Demo4 {
    public static void main(String[] args) throws IOException {
        File dir = new File("e:\\1905\\day17");

        File[] arr = dir.listFiles(new FilenameFilter(){
            
            public boolean accept(File dir, String name)  {
                 if(name.endsWith(".txt"))
                      return true;
                 else
                     return false;
            }
        });
        for(File ff:arr){
            sop(ff.getName());
        }
        /*
        File [] arr = dir.listFiles(new FilterByName(".txt"));

        for(File ff:arr){
            sop(ff.getName());
        }
        */
    }
    public static void sop(Object obj){
       System.out.println(obj);
    }
}

   ·递归

函数自己调用自己

//递归：函数自己调用自己,当函数调用次数太多的时候，容易内存溢出
class Demo5 {
    public static void main(String[] args) {
        int n = sum(3);
        System.out.println(n);
    }
    public static int sum(int num){
        if(num==1)
            return 1;
        else
            return num+sum(--num);
    }
}

 

   ·列出某个目录下的所有文件名，包括子目录下的文件名

import java.io.*;
public class Test2 {
    public static void main(String[] args) throws IOException{
        //列出某个目录下的所有内容，包括子目录中的内容
        File dir=new File("C:\\Users\\machenike\\Desktop\\培训\\java\\作业");
        lists(dir);
    }
    //列出某个目录下的所有内容，包括子目录中的内容
    public static void lists(File dir){
        System.out.println("dir:"+dir);

        File[] ff=dir.listFiles();

        for(File file:ff){
            if(file.isDirectory()){
                lists(file);
            }else
                System.out.println("file:"+file);
        }
    }
}

   ·删除某个目录下的内容，包括子目录里的内容

import java.io.*;
class Demo7 {
    public static void main(String[] args) throws IOException{
         //删除指定目录下的内容，包括子目录中的内容  文件夹中的内容全部删除，这个文件夹才能删除

        File dir=new File("e:\\1905\\day171");
        delDir(dir);
    }
    //删除指定目录下的内容，包括子目录中的内容
    public static void delDir(File dir)throws IOException{
        File[] files=dir.listFiles();
        for(File ff:files){
            if(ff.isDirectory()){
               delDir(ff);
            }else
                System.out.println(ff.getAbsolutePath()+":"+ff.delete());
        }
        System.out.println(dir.getAbsolutePath()+":"+dir.delete());
    }
}

   ·Scanner类

这个类，其实本质来说，不是一个流。它是一个浏览器、扫描器。可以从一个流中读取数据，也可以直接从一个文本中读取数据。
虽然Scanner不是一个流，在使用结束之后，也需要调用close()方法，进行关闭操作。
Scanner类也是AutoCloseable接口的实现类，因此，可以直接在try小括号中进行实例化，完成自动关闭。

package com.zqf;
import java.io.*;
import java.util.Scanner;
public class Test{
    public static void main(String[] args) throws FileNotFoundException, IOException {
        Scanner sc=new Scanner(new File("C:\\Users\\machenike\\Desktop\\a.txt"));
        while(sc.hasNextLine()) {
            
            System.out.println(sc.nextLine());
        }
    }
}

 

   ·打印流和直接输入输出流

package com.zqf;

import java.io.File;
import java.io.FileNotFoundException;
import java.io.PrintStream;

//重定向输出流: 标准输出流可以将数据写到控制台展示
        // 我们可以重定向标准输出流，实现将数据写入到某一个文件中

public class Test{
    public static void main(String[] args) throws FileNotFoundException  {
        PrintStream ps =new PrintStream(new File("C:\\Users\\machenike\\Desktop\\a.txt"));
        System.setOut(ps);
        System.out.println("你好啊");
    }
}

public class Test{
    public static void main(String[] args) throws FileNotFoundException  {
        File f=new File("C:\\Users\\machenike\\Desktop\\a.txt");
        System.setIn(new FileInputStream(f));
        Scanner sc=new Scanner(System.in);
        while(sc.hasNextLine()) {
            System.out.println(sc.nextLine());
        }
    }
}

 

 

 

 

 

   ·SequenceInputStream序列流

import java.io.*;
import java.util.*;
class Demo10 {
    public static void main(String[] args) throws IOException{
        
        //序列流：SequenceInputStream

        //Demo7,Demo8,Demo9  合并到一个新的文件中
        FileInputStream fis1 =new FileInputStream("Demo7.java");
        FileInputStream fis2 =new FileInputStream("Demo8.java");
        FileInputStream fis3 =new FileInputStream("Demo9.java");

        Vector<FileInputStream> v=new Vector<>();
        v.add(fis1);
        v.add(fis2);
        v.add(fis3);

        Enumeration en = v.elements();

        SequenceInputStream ss =new SequenceInputStream(en);

        FileOutputStream fos = new FileOutputStream("other.java",true);

        byte[] arr=new byte[1024];
        int len;
        while((len=ss.read(arr))!=-1){
           fos.write(arr,0,len);
        }
        ss.close();
        fos.close();
    }
}

   ·文件的分割

import java.io.*;
import java.util.*;
class Demo11 {
    public static void main(String[] args) throws IOException{
        //文件的分割
        File file = new File("ok.jpg");
        qieGe(file);
    }
    //文件的分割
    public static void qieGe(File file) throws IOException{
        //判断是不是文件
        if(!file.isFile())
            return;

        //把分割出的多个文件同一放在同一个文件夹下
        File dir = new File("fenge");
        if(!dir.exists())
            dir.mkdir();

        //读取被拆分的文件
        FileInputStream fis = new FileInputStream(file);

        FileOutputStream fos=null;

        byte[] arr=new byte[1024*1024*2];//每读够2M，就写入到一个新的文件

        int len=0,num=1;
        while((len=fis.read(arr))!=-1)
        {
            fos=new FileOutputStream(new File(dir,(num++)+".suipian"));
            fos.write(arr,0,len);
        }

        //附加说明信息，说明文件的类型，说明文件的个数
        Properties pro = new Properties();
        
        String fileName=file.getName();//ok.jpg
        String ext=fileName.substring(fileName.lastIndexOf(".")+1);

        pro.setProperty("fileType",ext);//put

        pro.setProperty("fileNumber",String.valueOf(--num));

        //把集合中的说明信息写入到文件
        //void store(OutputStream out, String comments)  
        fos=new FileOutputStream(new File(dir,"readme.txt"));
      
        pro.store(fos,"切割信息说明");//集合会把自己的键值对通过输出流对象写入到文件

        fis.close();
        fos.close();  
    }
}

   ·Serializable   序列化接口

对象的序列化：向文件中写入对象

对象的反序列化：从文件中读取对象

注意：如果需要序列化多个对象到本地，可以将这多个对象放到一个集合中，直接将这个集合序列化到本地即可。此时要求集合中的元素对应的类，必须实现Serializable接口。
误区: 序列化的文件中，不要同时存储多个对象的信息。

import java.io.*;
class Person  implements Serializable  //序列化接口 java.io.NotSerializableException: Person
{
    static final long serialVersionUID = 42L; //建议自己定义UID

    private   transient String name;  //瞬态 不参与序列化     //-6731926871520872939 52943123420856159
    private int age;

    Person(){}
    Person(String name,int age){
       this.name=name;
       this.age=age;
    }

    public String getName(){
       return name;
    }
    public int getAge(){
      return age;
    }
   
    public String toString(){
       return name+","+age;
    }
}
class Demo12 {
    public static void main(String[] args)throws IOException, ClassNotFoundException {
        // ObjectOutputStream  ObjectInputStream
        writeObj();

        readObj();
    }

    //从文件中读取对象--反序列化(依据Person.class)
    public static void readObj()throws IOException, ClassNotFoundException{
        ObjectInputStream ois=new ObjectInputStream(new FileInputStream("object.txt"));
        
        //Object readObject()  
        Person ren=(Person)ois.readObject();////-6731926871520872939 Person.class

        System.out.println(ren.getName()+","+ren.getAge());
    }

    //向文件中写入对象
    //输出对象---对象的序列化(要求：对象所属的类必须实现 Serializable接口)
    public static void writeObj()throws IOException {
        ObjectOutputStream oos=new ObjectOutputStream(new FileOutputStream("object.txt"));
        
        oos.writeObject(new Person("李四",28));//-6731926871520872939

        oos.close();
    }
}

   ·RandomAccessFile随机访问流

随机访问流
                      只能访问文件
       　　　　 内部既有字节输入流，也有字节输出流
                       内部使用了数组，使用指针实现随机访问

 

可以使用指针

import java.io.*;
class Demo13 {
    public static void main(String[] args) throws IOException,FileNotFoundException{
         //writeFile();
         readFile();
    }

    public static void readFile()throws FileNotFoundException,IOException{
       RandomAccessFile rf =new RandomAccessFile("random.txt","r");

       //默认从文件开头开始读
       byte[] arr=new byte[4];
       int len=rf.read(arr);

       int age=rf.readInt();
       System.out.print(new String(arr,0,len)+","+age);

       rf.seek(16);
       len = rf.read(arr);
       age=rf.readInt();

       System.out.print(new String(arr,0,len)+","+age);
    }

    public static void writeFile()throws FileNotFoundException,IOException{
       RandomAccessFile rf =new RandomAccessFile("random.txt","rw");
       
       //默认从文件的开头开始写入
        rf.write("赵四".getBytes());
        rf.writeInt(48);

        //获取指针指向的位置  long getFilePointer()  

        long num = rf.getFilePointer();//8
        System.out.println(num);

        rf.seek(16);//控制指针指向的位置

        rf.write("刘能".getBytes());
        rf.writeInt(58);

        num = rf.getFilePointer();//24
        System.out.println(num);

        rf.close();
    }
}

 day19

   ·内存流

ByteArrayInputStream:从内存中读     ByteArrayInputStream(byte[] buf)
ByteArrayOutputStream：向内存中写   ByteArrayOutputStream() 该类内部有一个字节数组，把数据写入到内部的字节数组

import java.io.*;
class  Demo1{
    public static void main(String[] args) throws IOException{
        //内存流: ByteArrayInputStream:从内存中读     ByteArrayInputStream(byte[] buf) 
        
        //        ByteArrayOutputStream：向内存中写   ByteArrayOutputStream() 该类内部有一个字节数组，把数据写入到内部的字节数组

         byte[] arr = "owieuroeuroeir".getBytes();

         ByteArrayInputStream bis =new ByteArrayInputStream(arr);
         ByteArrayOutputStream bos = new ByteArrayOutputStream();

         byte[] b=new byte[1024];
         int len=0;

         while((len=bis.read(b))!=-1){
             bos.write(b,0,len);
         }

         byte[] c = bos.toByteArray();//得到内部的字节数组
         System.out.println(new String(c));
    }
}

   ·数据字节流

import java.io.*;
class  Demo2{
    public static void main(String[] args) throws IOException{
        // DataInputStream  DataOutputStream    
        writeData();
        readData();
    }
    public static void readData()throws IOException{

        DataInputStream dis = new DataInputStream(new FileInputStream("data.txt"));

        double d = dis.readDouble();
        boolean b = dis.readBoolean();
        long l=dis.readLong();

        System.out.println(d+","+b+","+l);
    }
    public static void writeData()throws IOException{
       DataOutputStream  dos = new DataOutputStream(new FileOutputStream("data.txt"));

       dos.writeDouble(6.66);
       dos.writeBoolean(false);
       dos.writeLong(77);

       dos.close();
    }
}

 

   ·转换流设置编码

import java.io.*;
class  Demo3{
    public static void main(String[] args) throws IOException{
        //转换流可以设置编码
        //writeFile();
        readFile();
    }
    public static void readFile()throws IOException{
        InputStreamReader isr = new InputStreamReader(new FileInputStream("utf.txt"),"GBK");

        char[] arr=new char[10];// char ch;
        int num = isr.read(arr);
        System.out.println(new String(arr,0,num));    
    }
    public static void writeFile()throws IOException{
        //平台默认编码是GBK
        OutputStreamWriter isr = new OutputStreamWriter(new FileOutputStream("utf.txt"),"UTF-8");

        isr.write("你好");
        isr.close();   
    }
}

import java.util.*;
/*
编码：把字符转成字节
      byte[] getBytes() 
             使用平台的默认字符集将此 String编码为字节序列，将结果存储到新的字节数组中。  
      byte[] getBytes(Charset charset) 
             使用给定的charset将该String编码为字节序列，将结果存储到新的字节数组中。

解码：把字节转成字符
      String(byte[] bytes) 
             通过使用平台的默认字符集解码指定的字节数组来构造新的 String 。 
      String(byte[] bytes, Charset charset) 
             构造一个新的String由指定用指定的字节的数组解码charset 。 
*/
class  Demo4{
    public static void main(String[] args)throws Exception {

         byte[] arr = "你好".getBytes();  //编码 [-60, -29, -70, -61]

        System.out.println(Arrays.toString(arr));

        System.out.println(new String(arr));//解码


         arr = "你好".getBytes("UTF-8");  //编码 [-28, -67, -96, -27, -91, -67]

        System.out.println(Arrays.toString(arr));

        System.out.println(new String(arr,"UTF-8"));//解码

        //解码用的码要和编码用的码一致，否则乱码

        //编码编对了，解码解错了，处理方式：再编码，再解码

        byte[] b="你好".getBytes();//GBK编码

        String str=new String(b,"ISO8859-1");//解码 ????
        
        System.out.println(str);

        byte[] c=str.getBytes("ISO8859-1"); //再编码

        str=new String(c);//再解码

        System.out.println(str);    
    }
}

   ·进程与线程

/*
进程：
     正在进行中的程序
     也就是在内存中开辟的一块空间

线程：负责程序执行的一条执行路径
      也称为一个执行单元
      进程的执行实际上是线程在执行
      一个进程至少包括一个线程
      如果一个进程包括多个线程，那么就是多线程程序了

多线程实现了同时执行的效果，多个线程在互相争抢cpu，谁抢到谁执行，直到
线程把自己的代码全部执行完，线程结束

多线程一定能提高效率吗？不一定，但是能合理的利用cpu资源，关键是实现了
不同功能或相同功能的同时执行的效果 

java程序是多线程程序吗？
有一个负责程序正常执行的线程，主线程---》执行的是main方法中的代码
有一个负责垃圾回收的线程，垃圾回收线程 --》执行的是finalize方法中的代码

任务：线程执行的代码
      任务代码都有其存放位置

      主线程的任务代码在main方法中
      垃圾回收线程的任务代码在finalize方法中

线程是随着任务的存在而存在，随着任务的执行结束而结束
*/
//垃圾回收的功能定义在Object中   void  finalize()
class Test{
    public void finalize(){
       System.out.println("被回收了...");
    }
}
class Demo5 {
    public static void main(String[] args){ //一个程序至少会有一个线程：主线程，主线程负责执行main中的代码
           new Test();  //new Test().finalize()
           new Test();
           new Test();  //垃圾回收线程执行的垃圾回收的代码，任何一个对象都能被回收

           System.gc();//主线程执行完这行代码，说明主线程和垃圾回收线程挣抢cpu

           System.out.println("hello");    
    }
}

   ·线程创建一

/*
张三和李四同时show：

给张三创建一个线程
给李四创建一个线程

创建线程的方式：

1 创建一个Thread的子类
2.该子类重写run方法
    创建线程是为了执行任务，任务需要有存放位置
    run方法就是任务代码的存放位置
3.创建子类的对象
4.启动 start()：
     具备启动线程的功能
     启动的线程当得到cpu时会去执行run方法中的任务代码



public static void main(String[] args) //主线程
    {
           Thread t1=new Thread();
           Thread t2=new Thread();

           t1.start();
           t2.start();

           Thread 类中的run方法没有实现任何功能，任务代码又必须写在run方法中
           只能是继承Thread类，重写run方法
    }
*/
class Test extends Thread{
    private String name;
    Test(){}
    Test(String name){
       this.name=name;
    }
    public void run(){//该方法中写的是子线程的任务代码
       for(int i=1;i<=10;i++){                           //子线程的名字： Thread-编号  编号从0开始
            System.out.println(Thread.currentThread().getName()+":"+name+"......show"+i);
        }
    }
}
class Demo6 {
    public static void main(String[] args){ //主线程

        Test t1=new Test("张三");//创建了一个线程  子线程
        Test t2=new Test("李四");//创建了一个线程

        t1.start();
        t2.start();

        System.out.println(Thread.currentThread().getName());//main
    }
}

   ·线程间异常互不影响

//每个线程发生异常只是这个线程自己的事儿，不会影响其它线程
class Test extends Thread{
    private String name;
    Test(){}
    Test(String name){
       this.name=name;
    }
    public void run(){
        //int[] arr=new int[5];
       for(int i=1;i<=10;i++){       
            //System.out.println(arr[5]);
            System.out.println(Thread.currentThread().getName()+":"+name+"......show"+i);
        }
    }
}
class Demo7{
    public static void main(String[] args) {
        Test t1=new Test("张三");
        Test t2=new Test("李四");

        t1.start();
        t2.start();

        //System.out.println(5/0);
        System.out.println(Thread.currentThread().getName());
    }
}

   ·线程状态

 day20

   ·创建线程第二种方法（常用）

/*

四个窗口同时卖票：

因为是同时所以使用多线程
创建四个线程，每个线程的任务都是卖票
因为都是卖票，所以只需要创建一个继承Thread的子类

创建四个线程，出现了200张票，所以需要把票修饰为static的

并不是每个成员变量都适合修饰为static，那么在不使用static的情况下怎么让
4个线程共享50张票？

创建线程的第二种方式：

1: 定义一个类实现Runnable接口
2：子类重写run方法
3：创建子类的对象
4：创建Thread对象，同时把子类对象作为参数传递给Thread对象
*/

//定义任务类：把任务面向对象，这个任务类和线程没关系
//线程执行什么任务不再重要了，只要是实现了Runnable接口的子类对象都可以作为参数传递给线程对象
//这种方式更面向对象，任务有任务类，线程有线程类，把线程执行的任务作为参数传递给线程

//实现接口的同时还可以再继承其它类
class Ticket implements Runnable//extends Thread{
    private  int num=50;
    //任务：卖票
    public void run(){
        while(true){
            if(num>0){
                System.out.println(Thread.currentThread().getName()+"...sale..."+num--);
            }
        }
    }
}
class Demo2 {
    public static void main(String[] args) {
        Ticket t=new Ticket();//任务对象
        
        Thread t1=new Thread(t);//线程对象，创建一个线程
        Thread t2=new Thread(t);
        Thread t3=new Thread(t);
        Thread t4=new Thread(t);
        t1.start();t2.start();t3.start();t4.start()    
    }

 

   ·多线程安全   锁机制 同步synchronized

/*
多线程程序的安全问题：
          因为每个线程再次抢到cpu，直接执行后边的代码，所以会出现0,-1,-2

          出现安全问题的原因：
          1：多个线程用到了共享数据
          2:操作共享数据的语句有多条，当操作共享数据的多条语句还没执行完就被抢走了cpu

          解决方式：一个线程在执行操作共享数据的多条语句时，只有全部执行完这多条语句其它线程才能执行

          同步代码块:
          synchronized(对象){
              需要被同步的代码（操作共享数据的多条语句）
          }

          使用同步代码块解决了安全问题：
                同时程序性能会降低，因为需要获取锁，释放锁，没有拿到锁的线程还得反复的判断锁
*/
class Ticket implements Runnable
{
    private  int num=50;
    private Object obj = new Object();

    public void run()//throws InterruptedException//重写的方法，需要和父类中的方法一致
    {
        while(true)
        {
            synchronized(obj)//获取锁：锁可以是任意对象
            {
                if(num>0)
                {
                    //睡眠的线程放弃cpu了,睡眠的线程不会释放锁
                    try{Thread.sleep(10);}catch(InterruptedException e){e.printStackTrace();}
                    System.out.println(Thread.currentThread().getName()+"...sale..."+num--);//1 0 -1  -2
                }
            }//释放锁
        }
    }
}

class Demo4 
{
    public static void main(String[] args) 
    {
        Ticket t=new Ticket();
        
        Thread t1=new Thread(t);
        Thread t2=new Thread(t);
        Thread t3=new Thread(t);
        Thread t4=new Thread(t);

        t1.start();t2.start();t3.start();t4.start();
        
    }
}

 

 

   ·设计一个死锁

package com.zqf;

public class Test {
    public static void main(String[] args) {
        Lock l=new Lock();
        Lock2 l2=new Lock2();
        Thread A=new Thread(l);
        Thread B=new Thread(l2);
        A.start();B.start();
    }
}
class Lock implements Runnable{
    public void run() {
        synchronized ("A") {
            System.out.println("A线程A锁已经获得，等B锁");
            synchronized ("B") {
                System.out.println("A线程B锁也获得了");
                "B".notify();
            }
        }
    }    
}
class Lock2 implements Runnable{
    public void run() {
        synchronized ("B") {
            System.out.println("B线程B锁获得了，等A锁");
            try {
                "B".wait();
            } catch (InterruptedException e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
            }
            synchronized ("A") {
                System.out.println("B线程A锁也获得了");            
            }
        }
    }    
}

 

   ·银行存钱

 

public synchronized  void save(double money)//同步函数:函数中的代码全部放在了同步代码块中那么该函数可以是同步函数

//这个是我自己写的
package com.zqf;
public class Test{
    public static void main(String[] args) {
        Cun c=new Cun();
        Thread t=new Thread(c,"小明");
        Thread t2=new Thread(c,"小黄");
        t2.start();t.start();
    }
}
class Cun implements Runnable{
    int num=0;
    @Override
    public void run() {
        
            for(int i=0;i<20;i++) {
                synchronized (Cun.class) {
                num=num+100;
                System.out.println(Thread.currentThread().getName()+num);
            }
        }
        
    }
    
}

//下面为老师写的

/*
有一个银行，可以存钱
有两个客户，同时存钱，每人存3次，每次存100
*/
class Bank{
    private double sum;//总的钱数
    private Object obj = new Object();
    //存钱
    public synchronized  void save(double money)//同步函数:函数中的代码全部放在了同步代码块中那么该函数可以是同步函数
    {
       // synchronized(obj)
        //{
            sum=sum+money;
            System.out.println("sum="+sum);
        //}
    }
}
//任务类
class Comstomer implements Runnable{
     private Bank bank = new Bank();
     public void run() {
        for(int i=1;i<=3;i++){
             bank.save(100);
         }
     }
}
class Demo5 {
    public static void main(String[] args) {
        Comstomer com=new Comstomer();

        Thread t1=new Thread(com);
        Thread t2=new Thread(com);

        t1.start();
        t2.start();
    }
}

   ·同步函数与异步函数的锁

/*
 同步函数的锁是this
 静态同步函数：静态进内存的时候没有对象，只有那个字节码，所以锁是其所在类的字节码
*/
class Ticket implements Runnable{
    private static int num=50;
    private Object obj = new Object();
    boolean flag=true;

    public void run(){
        if(flag){
            while(true){
                synchronized(Ticket.class)//t1 obj 字节码也是对象
                {
                    if(num>0){                        
                        try{Thread.sleep(10);}catch(InterruptedException e){e.printStackTrace();}
                        System.out.println(Thread.currentThread().getName()+"...sale..."+num--);
                    }
                }
            }
        }else{ 
             while(true) //t2 this
                 fun();
        }
    }
    public static synchronized void fun(){
        if(num>0){        
            try{Thread.sleep(10);}catch(InterruptedException e){e.printStackTrace();}
            System.out.println(Thread.currentThread().getName()+"...sale..."+num--);
        }
    }
}
class Demo6 {
    public static void main(String[] args) {
        Ticket t=new Ticket();
        
        Thread t1=new Thread(t);
        Thread t2=new Thread(t);
        
        t1.start();

        try{Thread.sleep(10);}catch(InterruptedException e){e.printStackTrace();}
         
        t.flag=false;

        t2.start();    
    }
}

   ·单例设计模式懒汉式多线程安全问题

//单例设计模式懒汉式多线程安全问题

//饿汉式
class Single {
    private static Single s;
    private Single(){}

    public static Single getInstance(){
       synchronized(Single.class){
            if(s==null)    {  
                 try{Thread.sleep(10);}catch(InterruptedException e){e.printStackTrace();}
                 s = new Single();
            }
        }
         return s;
    }
}
class Task implements Runnable{
    public void run(){
        Single ss = Single.getInstance();
        System.out.println(ss);
    }
}
class Demo7 {
    public static void main(String[] args) {
        Task task = new Task();

        Thread t1 = new Thread(task);
        Thread t2 = new Thread(task);

        t1.start();   t2.start();
    }
}

   ·多线程通信

线程间的通信：多个线程的任务不同，但是操作的数据相同

共同操作的数据

 

wait(),notify()(唤醒一个线程),notifyAll(）（唤醒所有线程）这些方法必须使用锁
锁是任意的对象，说明这些方法wait(),notify(),notifyAll(）是任意对象都能方法用的方法

//线程间的通信：多个线程的任务不同，但是操作的数据相同

//共同操作的数据

/*

wait(),notify()(唤醒一个线程),notifyAll(）（唤醒所有线程）这些方法必须使用锁
锁是任意的对象，说明这些方法wait(),notify(),notifyAll(）是任意对象都能方法用的方法
*/
class Res{
    String name;
    String sex;
    boolean flag;
}

//实现赋值的线程的任务
class Input implements Runnable{
    private Res res;
    Input(Res res){
       this.res=res;
    }
    public void run(){
         int i=0;
         while(true){
           synchronized(res){
                //先判断能不能赋值
                if(res.flag==true){
                    try{
                          res.wait();//等待的线程会释放锁
                    }catch(InterruptedException e){
                        e.printStackTrace();
                    }
                 }
                if(i==0){
                   res.name="张征";
                   res.sex="男";
                 }else{
                   res.name="王财昌";
                   res.sex="女";
                 }
                 res.flag=true;
                 res.notify();//如果没有等待的线程则是空唤醒  
             }
            i=(i+1)%2;
         }
    }
}

//实现输出值的线程任务
class Output implements Runnable{
    private Res res;

    Output(Res res){
       this.res=res;
    }
    public void run(){
       while(true){
           synchronized(res){
               //先判断能不能输出值
               if(res.flag==false){
                   try{
                          res.wait();//等待的线程会释放锁  让res这个锁上的线程去等待
                    }catch(InterruptedException e){
                        e.printStackTrace();
                    }
                }
               System.out.println(res.name+"..."+res.sex);

               res.flag=false;
               res.notify(); //唤醒res这个锁上的线程
            }
        }
    }
}

class Demo9 {
    public static void main(String[] args) {
        //创建数据
        Res res =new Res();

        //创建赋值线程的任务对象
        Input in=new Input(res);

        //创建输出值线程的任务对象
        Output out = new Output(res);

        //创建赋值的线程
        Thread t1 = new Thread(in);

        //创建输出值的线程
        Thread t2 = new Thread(out);

        t1.start();
        t2.start();
    }
}

　　第二种方法：

class Res{
    private String name;
    private String sex;
    private boolean flag;

    //赋值功能
    public synchronized void set(String name,String sex){
       if(flag){
           try{
               this.wait();
           }catch(InterruptedException e){
               e.printStackTrace();
           }
        }

       this.name=name;
       this.sex=sex;

       flag=true;
       this.notify();
    }

    // 输出值
    public synchronized void out(){
          if(!flag){
               try{
                   this.wait();
               }catch(InterruptedException e){
                   e.printStackTrace();
               }
           }
          System.out.println(name+"..."+sex);

          flag=false;
          this.notify();
    }
}

//实现赋值的线程的任务
class Input implements Runnable{
    private Res res;
    Input(Res res){
       this.res=res;
    }
    public void run(){
         int i=0;
         while(true){
                if(i==0){
                    res.set("张征","男");
                 }else{
                    res.set("王财昌","女");
                 }                
               i=(i+1)%2;
         }
    }
}

//实现输出值的线程任务

class Output implements Runnable{
    private Res res;
    Output(Res res){
       this.res=res;
    }
    public void run(){
       while(true){
            res.out();
        }
    }
}

class Demo10{
    public static void main(String[] args) {
        //创建数据
        Res res =new Res();

        //创建赋值线程的任务对象
        Input in=new Input(res);

        //创建输出值线程的任务对象
        Output out = new Output(res);

        //创建赋值的线程
        Thread t1 = new Thread(in);

        //创建输出值的线程
        Thread t2 = new Thread(out);

        t1.start();
        t2.start();
    }
}

   ·消费者与生产者

//自己写的
package com.zqf;

import com.sun.swing.internal.plaf.synth.resources.synth;

public class Test2{
    public static void main(String[] args) {
        Product p=new Product();
        ShengChan sc=new ShengChan(p);
        XiaoFei xf=new XiaoFei(p);
        Thread t=new Thread(sc,"商家");
        Thread tw=new Thread(xf,"买家");
        t.start();tw.start();
    }
}
class Product{
    private String name;
    private int count=0;
    private boolean flag;
    public Product() {
        super();
    }
    public Product(String name, int count) {
        super();
        this.name = name;
        this.count = count;
    }
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    public int getCount() {
        return count;
    }
    public void setCount(int count) {
        this.count = count;
    }
    @Override
    public String toString() {
        return "Product [name=" + name + ", count=" + count + "]";
    }
    
    public synchronized void sheng(String name) {
        if(flag==true) {
            try {
                this.wait();
            } catch (InterruptedException e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
            }
        }else {
            this.name=name;
            count+=1;
            System.out.println(Thread.currentThread().getName()+"---生产---"+name+"有"+count);
            flag=true;
            this.notify();
        }
    }
    public synchronized void xiao() {
        if(flag==false) {
            try {
                this.wait();
            } catch (InterruptedException e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
            }
        }else {
            System.out.println(Thread.currentThread().getName()+"---消费---"+name+"有"+count);
            flag=false;
            this.notify();
        }
    }
}
class ShengChan implements Runnable{
    private Product p;
    public ShengChan(Product p) {
        super();
        this.p = p;
    }
    public  void run() {
        while(true) {
            p.sheng("哆啦A梦");
        }
    }    
}
class XiaoFei implements Runnable{
    private Product p;
    public XiaoFei(Product p) {
        super();
        this.p = p;
    }
    public  void run() {
        while(true) {
            p.xiao();
        }
    }    
}

 

/*
生产者消费者问题

生产者负责生产
消费者负责消费

生产者有生产任务
消费者有消费任务

需要定义生产任务
需要定义消费任务

还需要定义产品
*/
class Product {
    private String name;
    private int count;
    private boolean flag;

    //生产功能
    public synchronized void produce(String name){
         if(flag==true)
             try{this.wait();}catch(InterruptedException e){e.printStackTrace();}

         this.name=name+"..."+count;
         count++;

         System.out.println(Thread.currentThread().getName()+"...生产了..."+this.name);

          flag=true;
          this.notify();
    }
    //消费功能

    public  synchronized void consume(){
        if(!flag)
           try{this.wait();}catch(InterruptedException e){e.printStackTrace();}
        
        System.out.println(Thread.currentThread().getName()+"...消费了..."+this.name);

        flag=false;
        this.notify();
    }
    
}

//生产任务
class Produce implements Runnable{
     private Product  pro;

     Produce(Product pro){
        this.pro = pro;
     }

     public void run(){
        while(true){
           pro.produce("笔记本");
         }
     }
}

class Consume implements Runnable{
     private Product  pro;

     Consume(Product pro){
        this.pro = pro;
     }

     public void run(){
        while(true){
            pro.consume();
         }
     }
}

class Demo11 {
    public static void main(String[] args) {
        Product pro = new Product();

        Produce produce = new Produce(pro);

        Consume consume = new Consume(pro);

        Thread t1 = new Thread(produce);
        Thread t2 = new Thread(consume);

        t1.start();
        t2.start();
    }
}

 

   ·线程池

　　线程池，可以理解为是一个容器，存储线程对象。
　　当我们需要开辟一个线程的时候，就去开辟一个新的线程。当这个线程使用结束之后，这个线程就会被销毁。然后再使用到线程的时候，再去开辟新的线程。这样的过程，对CPU来讲，是一种消耗。
 　   线程池，最核心的原理是“复用”。当我们需要使用到一个线程的时候，从线程池中获取；如果线程池中没有线程，此时再去实例化新的线程。当一个线程使用结束之后，再把这个线程不是销毁掉，而是放入线程池，以便下次继续使用。

public ThreadPoolExecutor(int corePoolSize,
                              int maximumPoolSize,
                              long keepAliveTime,
                              TimeUnit unit,
                              BlockingQueue<Runnable> workQueue,
                              RejectedExecutionHandler handler)

在上述的构造方法中，有几个参数说明:

int corePoolSize: 核心池的大小。
int maximumPoolSize: 线程池中最多有多少线程。（包括核心线程和临时开辟的线程）
long keepAliveTime: 临时开辟的线程最多可以空闲的时间。
TimeUnit unit: 空闲时间的单位。
BlockingQueue<Runnable> workQueue: 任务的等待队列。
    ArrayBlockingQueue、LinkedBlockingQueue、SynchronousQueue
RejectedExecutionHandler handler: 拒绝访问策略。
    AbortPolicy                : 丢弃新的任务，并抛出异常 RejectedExecutionException
    DiscardPolicy            : 丢弃新的任务，但是不抛出异常
    DiscardOldestPolicy        : 丢弃等待队列中最早的任务
    CallerRunsPolicy        : 不会开辟新的线程，由当前线程执行这个任务

注意事项:
 在使用线程池的时候，不需要我们手动的开辟线程。在使用线程池的时候，需要注意的地方，就是任务的处理。在线程池中有一个方法 execute(Runnable r) ，往线程池中添加任务。线程池内部的线程开辟与销毁由自己处理，与我们无关。

execute(Runnable r)：向线程池中添加任务，线程池会自动的分配线程去处理这个任务。

shutdown()：停止线程池。
　　　　 线程池的停止，是需要我们手动关闭的。而且，这个方法并不是立即停止掉线程池。
　　　　 如果线程池中还有线程在处理任务，此时这个方法不会让线程池立即停止，而是发出一个停止的信号。等这个线程处理完了任务，线程池才会终止。

 shutdowNow(): 立刻停止线程池。

 

   ·使用工具类获取线程池

工具类：Executors

// 1、获取一个线程池，这个线程池中只有一个核心线程，等待队列中的任务数量是 Integer.MAX_VALUE
ExecutorService executor1 = Executors.newSingleThreadExecutor();
executor1.submit(new MyTask(1));
executor1.shutdown();

// 2、获取一个线程池，这个线程池中有指定数量的核心线程和最大线程，等待队列中的任务数量是 Integer.MAX_VALUE
ExecutorService executor2 = Executors.newFixedThreadPool(5);
executor2.submit(new MyTask(1));        
executor2.submit(new MyTask(2));        
executor2.submit(new MyTask(3));        
executor2.submit(new MyTask(4));        
executor2.submit(new MyTask(5));        
executor2.submit(new MyTask(6));        

executor2.shutdown();

// 3、获取一个线程池，这个线程池中没有核心线程，有Integer.MAX_VALUE数量的临时线程
ExecutorService executor3 = Executors.newCachedThreadPool();
executor3.submit(new MyTask(1));        
executor3.submit(new MyTask(2));        
executor3.submit(new MyTask(3));        
executor3.submit(new MyTask(4));        
executor3.submit(new MyTask(5));        
executor3.submit(new MyTask(6));

        executor3.shutdown();

 

   ·线程池的应用

package com.zqf;

import java.util.concurrent.ArrayBlockingQueue;
import java.util.concurrent.ThreadPoolExecutor;
import java.util.concurrent.TimeUnit;

public class Test {
    public static void main(String[] args) {
        // 1、实例化一个线程池对象
        /*
         public ThreadPoolExecutor(int corePoolSize,
                              int maximumPoolSize,
                              long keepAliveTime,
                              TimeUnit unit,
                              BlockingQueue<Runnable> workQueue,
                              RejectedExecutionHandler handler)
         */
        ThreadPoolExecutor pool = new ThreadPoolExecutor(5, 
                                                         10, 
                                                         1, 
                                                         TimeUnit.SECONDS, 
                                                         new ArrayBlockingQueue<>(5), 
                                                         new ThreadPoolExecutor.CallerRunsPolicy());
        
        // 线程池属性的设置:
        // pool.setCorePoolSize(5);
        // pool.setMaximumPoolSize(10);
        // pool.setKeepAliveTime(2, TimeUnit.DAYS);
        // pool.setRejectedExecutionHandler(handler);
        
        for (int i = 0; i < 16; i++) {
            // 往线程池中添加任务
            pool.execute(new MyTask(i));
        }
        
        // 关闭线程池
        pool.shutdown();        
        // pool.shutdownNow();
    }
}
class MyTask implements Runnable {

    private int id;
    public MyTask(int id) {
        this.id = id;
    }

    @Override
    public void run() {
        System.out.println("线程: " + Thread.currentThread().getName() + "准备处理" + id + "号任务");
        
        // 模拟任务的处理
        try {
            Thread.sleep(2000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }    
        
        System.out.println("线程: " + Thread.currentThread().getName() + "已经处理完" + id + "号任务!");
    }
}

 

 

 

 

·反射   获取字节码对象

 Class<?> aClass = Class.forName("com.reflect.Person");//Person.class    最常用，其它两个了解即可

Class claz =  Person.class;

Person person = new Person();
          Class<? extends Person> claz = person.getClass();//Person.class

package com.reflect;

public class Person {
    private String name;//Field
    private int age;

    public Person() { }

    public Person(String name, int age){ //Constructor
    
        this.name = name;
        this.age = age;
    }
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    public int getAge() {
        return age;
    }
    public void setAge(int age) {
        this.age = age;
    }
    public static void ff(){
        System.out.println("hello");
    }
    public void show(){ //Method
   
        System.out.println("show");
    }
    public void fun(String name){
        System.out.println(name);
    }
    public String toString() {
        return "Person{" +"name='" + name + '\'' +", age=" + age +'}';
    }
}

package com.reflect;

public class Demo1 {
    //反射:动态获取字节码对象，并对其执行
    public static void main(String[] args) throws ClassNotFoundException{
        // m1();
         //m2();
         //m3();
    }
    /*
    // alt+enter   alt+insert
    public static void m3() throws ClassNotFoundException{    //static Class<?>    forName(String className)
        Class<?> aClass = Class.forName("com.reflect.Person");//Person.class
        Class<?> aClass2 = Class.forName("com.reflect.Person");
        System.out.println(aClass==aClass2);
    }

    public static void m2(){
        //每种数据类型都有一个class类型的属性，这个属性得到的就是字节码对象
        Class claz =  Person.class;
        Class claz2 = Person.class;
        System.out.println(claz==claz2);
    }

    //得到Person.class   Class<?>  getClass()
    //这种方式需要事先创建一个Person对象
    public static void m1(){
          Person person = new Person();
          Class<? extends Person> claz = person.getClass();//Person.class
          Class<? extends Person> claz2 = person.getClass();//Person.class

           System.out.println(claz==claz2);
    }
    */
}

   ·反射   创建类对象

package com.reflect;

import java.lang.reflect.Constructor;
import java.lang.reflect.InvocationTargetException;

public class Demo2 {

    //动态得到字节码，并创建对象
    public static void main(String[] args) throws IllegalAccessException, InstantiationException, ClassNotFoundException, NoSuchMethodException, InvocationTargetException {
        m2();
    }

    public static void m2() throws ClassNotFoundException, NoSuchMethodException, IllegalAccessException, InvocationTargetException, InstantiationException {
        Class claz=Class.forName("com.reflect.Person");
        // 得到构造方法对应的Constructor类型的对象
       Constructor con = claz.getConstructor(String.class,int.class);

       //使用带参数的构造方法创建对象 newInstance(Object... initargs)
        Object obj = con.newInstance("李四", 20);

        System.out.println(obj);
    }

    public static void m1() throws ClassNotFoundException, IllegalAccessException, InstantiationException {

        Class claz=Class.forName("com.reflect.Person");//Person.class

        //创建对象  Person ren = new Person();

        Person o = (Person) claz.newInstance();//使用的空参的构造方法，使用Class类提供的newInstance()方法创建对象

        System.out.println(o);
    }
}

   ·反射   获取属性并赋值

package com.reflect;
import java.lang.reflect.Field;
public class Demo3 {
    //动态得到字节码对象，并给属性赋值
    public static void main(String[] args) throws ClassNotFoundException, NoSuchFieldException, IllegalAccessException, InstantiationException {

        Class claz=Class.forName("com.reflect.Person");

        //给name属性赋值   Field     getField(String name)

        //Field field=claz.getField("name");//只能得到public权限的属性
        //System.out.println(field);//java.lang.NoSuchFieldException: name
       Field field= claz.getDeclaredField("name");

       //void set(Object obj, Object value)
        //name是非静态属性，必须通过对象来赋值
        Person obj=(Person)claz.newInstance();

        //void setAccessible(boolean flag)
        field.setAccessible(true);// 设置为可访问的
        field.set(obj,"张三");

        System.out.println(obj);
    }
}

   ·反射   获取类方法并使用

package com.reflect;
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;

public class Demo4 {
    public static void main(String[] args) throws ClassNotFoundException, NoSuchMethodException, InvocationTargetException, InstantiationException, IllegalAccessException {
        m3();
    }
    public static void m3() throws ClassNotFoundException, NoSuchMethodException, InvocationTargetException, IllegalAccessException {
        Class claz=Class.forName("com.reflect.Person");

        Method m = claz.getMethod("ff",null);

        m.invoke(null,null);
    }
    public static void m2() throws ClassNotFoundException, NoSuchMethodException, IllegalAccessException, InstantiationException, InvocationTargetException {
        Class claz=Class.forName("com.reflect.Person");

        Method m = claz.getMethod("fun",String.class);

        Person ren = (Person)claz.newInstance();

        m.invoke(ren,"呵呵");
    }
    public static void m1() throws ClassNotFoundException, NoSuchMethodException, IllegalAccessException, InstantiationException, InvocationTargetException {

        Class claz=Class.forName("com.reflect.Person");

       //getMethod(String name, Class<?>... parameterTypes) 

        Method method = claz.getMethod("show", null);

        //执行方法，这个方法是非静态方法 invoke(Object obj, Object... args)
        Person ren = (Person)claz.newInstance();
        method.invoke(ren,null);
    }
}

 day21

   ·sql

DDL**（Data Definition Language）：数据定义语言，用来定义数据库对象：库、表、列等； CREATE、 ALTER、DROP

DML***（Data Manipulation Language）：数据操作语言，用来定义数据库记录（数据）；     INSERT、 UPDATE、 DELETE

DCL（Data Control Language）：数据控制语言，用来定义访问权限和安全级别；grant

DQL*****（Data Query Language）：数据查询语言，用来查询记录（数据）。select

 

       数据库创建好以后，需要指定使用哪一个数据库：use 数据库名;

       查看当前被使用的数据库:   select database();

       删除数据库: drop database 数据库名;

 

数据库是用表来存放数据的：在数据库中创建表

        create table 表名(
  字段名   数据类型，
  字段名   数据类型，
  字段名   数据类型,

  。。。。
  字段名   数据类型
 );

        数据类型:
      数值型：int,tinyint,bigint

      小数: float(x,y)  double(x,y)  decimal(x,y)

      字符型: varchar(50)  实际需要的字符个数小于50，只分配需要的空间大小，

              lisi 分配4个字符的空间

       char(50)    实际需要的字符个数小于50,依然分配50个字符的空间大小

       lisi 分配50个字符的空间

       text:大文本

             日期时间类型：
              date:日期   年月日
              time：时间  时分秒 
              datetime： 日期时间类型  年月日时分秒
       timestamp：时间戳类型  年月日时分秒  2023

              二进制类型: blob

 
         查看所有表： show tables;

  修改表的时候添加字段:   alter table worker add image blob;

  修改表的时候修改字段:   alter table worker modify name varchar(60);

  修改表的时候删除字段:   alter table worker drop age;

  修改表名: rename table worker to yuangong;

  查看创建表的sql语句： show create table 表名;

  修改表的编码：alter table 表名 character set utf8;

  删除表: drop table 表名;

  表的编码默认和所在的数据库的编码一致

 

向表中添加记录：一次添加一条记录

         insert into 表名 values(数值1，数值2，。。。)

         
         向表中所有字段上添加值

  insert into yuangong  values(110,'lisi','nan','2009-12-10',120.5,'hehe');

  向表中部分字段添加值，需要把字段名列出来

  insert into yuangong(number,name,sex) values(119,'zhangsan','nv');

  注意：  数值要和表中字段在个数，顺序，类型上保持一致

 

修改表中记录:

         update 表名 set 字段名=值,字段名=值,...[where 条件]

 

删除记录：delete from 表名 [where 条件]

          truncate table 表名

一个网站的访问的用户是不能添加，修改，删除数据的

我们从京东网站上看到的商品信息是从数据库中查询出来的

查询：

 

-- 条件查询
SELECT * FROM stu

-- 查询性别为女，并且年龄15的记录
SELECT * FROM stu WHERE gender='female' AND age=15

-- 查询学号为S_1001，或者姓名为liSi的记录
SELECT * FROM stu WHERE sid='S_1001' OR sname='liSi'

-- 查询学号为S_1001，S_1002，S_ 1003的记录
SELECT * FROM stu WHERE sid='S_1001' OR sid='S_1002' OR sid='S_1003'

SELECT * FROM stu WHERE sid IN('S_1001','S_1002','S_1003') 

SELECT * FROM stu WHERE sid NOT IN('S_1001','S_1002','S_1003')

-- 查询年龄为null的记录
SELECT * FROM stu WHERE age IS NULL  -- 查询年龄未知的学生

-- 查询年龄不为null的记录 -- 查询有年龄的学生
SELECT * FROM stu WHERE age IS NOT NULL

-- 查询年龄在20到40之间的学生记录
SELECT * FROM stu WHERE age>=20 AND age<=40
SELECT * FROM stu WHERE age BETWEEN 20 AND 40

-- 查询性别非男的学生记录
SELECT * FROM stu WHERE gender!='male'
SELECT * FROM stu WHERE gender<>'male'
SELECT * FROM stu WHERE gender='female'
SELECT * FROM stu WHERE NOT gender='male'

-- 模糊查询

-- 查询姓名由5个字母构成的学生记录

   SELECT * FROM stu WHERE sname LIKE '_____'

-- 查询姓名由5个字母构成，并且第5个字母为“i”的学生记录
   SELECT * FROM stu WHERE sname LIKE '____i'

-- 查询姓名以“z”开头的学生记录
   SELECT * FROM stu WHERE sname LIKE 'z%'

-- 查询姓名中第2个字母为“i”的学生记录
   SELECT * FROM stu WHERE sname LIKE '_i%'

-- 查询姓名中包含“a”字母的学生记录
   SELECT * FROM stu WHERE sname LIKE '%a%'

  
  
   SELECT * FROM emp

-- 去除重复 DISTINCT

   SELECT DISTINCT deptno FROM emp

-- 查雇员的月薪与佣金之和 :任何类型的数据和NUll运算，结果是NULL
   SELECT ename,sal+IFNULL(comm,0)  FROM emp

-- 给字段起别名
   SELECT ename,sal+IFNULL(comm,0) AS 总工资  FROM emp

-- 查看雇员的月薪与佣金之和
   SELECT ename,sal+IFNULL(comm,0) 总工资  FROM emp
  
  
   -- 排序  order by 字段 默认是升序排序(ASC)  降序(DESC)

SELECT * FROM stu
-- 查询所有学生记录，按年龄升序排序--默认是升序排序
SELECT * FROM stu ORDER BY age ASC

-- 查询所有学生记录，按年龄降序排序
SELECT * FROM stu ORDER BY age DESC

-- 查询所有学生记录，按姓名降序排序
SELECT * FROM stu ORDER BY sname DESC

SELECT * FROM emp
-- 查询所有雇员，按月薪降序排序，如果月薪相同时，按编号升序排序
SELECT * FROM emp ORDER BY sal DESC,empno   -- 先按照前边的字段排序，再按照后边的字段排序

 day22

数据库：存储、维护和管理数据

mysql，oracle,db2,sql server属于关系型数据库

mysql是一个数据库服务: 有自己占用的端口 3306 (0-65535,0-1024)

使用mysql必须保证服务是启动的:

启动方式：手动：到服务中找到mysql服务名，然后右击启动
          使用命令启动：net start mysql     net stop mysql

 

连接到mysql  ：  
        mysql -u root -p

SQL：Structure Query Language。（结构化查询语言）

SQL的分类：
DDL： 数据定义 create alter drop

DML:  数据操作 insert  delete  update

DCL:  数据控制

DQL:  数据查询 select

使用mysql首先需要创建数据库：

   create  database 数据库名;

   show databases; 查看数据库

   数据库中存储的是文本数据，所以数据库有编码，编码就是在安装mysql时设置的，查看数据库编码的方式如下:

        show create database d2;
 +----------+-------------------------------------------------------------+
 | Database | Create Database                                             |
 +----------+-------------------------------------------------------------+
 | d2       | CREATE DATABASE `d2` /*!40100 DEFAULT CHARACTER SET utf8 */ |
 +----------+-------------------------------------------------------------+
     
       create database d3 character set GBK;  -- 在创建数据库时指定编码

       show character set;  -- 查看所有编码

       create database d4 character set gbk collate  gbk_chinese_ci;  --  设置编码，同时设置排序方式

       alter database d4 character set utf8;  -- 修改数据库的编码

       --正常都使用默认的编码和默认的排序方式

       数据库创建好以后，需要指定使用哪一个数据库：use 数据库名;

       查看当前被使用的数据库:   select database();

       删除数据库: drop database 数据库名;

 

数据库是用表来存放数据的：在数据库中创建表

        create table 表名(
  字段名   数据类型，
  字段名   数据类型，
  字段名   数据类型,

  。。。。
  字段名   数据类型
 );

        数据类型:
      数值型：int,tinyint,bigint

      小数: float(x,y)  double(x,y)  decimal(x,y)

      字符型: varchar(50)  实际需要的字符个数小于50，只分配需要的空间大小，

              lisi 分配4个字符的空间

       char(50)    实际需要的字符个数小于50,依然分配50个字符的空间大小

       lisi 分配50个字符的空间

       text:大文本

             日期时间类型：
              date:日期   年月日
              time：时间  时分秒 
              datetime： 日期时间类型  年月日时分秒
       timestamp：时间戳类型  年月日时分秒  2023

              二进制类型: blob

 
         查看所有表： show tables;

  修改表的时候添加字段:   alter table worker add image blob;

  修改表的时候修改字段:   alter table worker modify name varchar(60);

  修改表的时候删除字段:   alter table worker drop age;

  修改表名: rename table worker to yuangong;

  查看创建表的sql语句： show create table 表名;

  修改表的编码：alter table 表名 character set utf8;

  删除表: drop table 表名;

  表的编码默认和所在的数据库的编码一致

 

向表中添加记录：一次添加一条记录

         insert into 表名 values(数值1，数值2，。。。)

         
         向表中所有字段上添加值

  insert into yuangong  values(110,'lisi','nan','2009-12-10',120.5,'hehe');

  向表中部分字段添加值，需要把字段名列出来

  insert into yuangong(number,name,sex) values(119,'zhangsan','nv');

  注意：  数值要和表中字段在个数，顺序，类型上保持一致

 

修改表中记录:

         update 表名 set 字段名=值,字段名=值,...[where 条件]

 

删除记录：delete from 表名 [where 条件]

          truncate table 表名

一个网站的访问的用户是不能添加，修改，删除数据的

我们从京东网站上看到的商品信息是从数据库中查询出来的

查询：select * from 表名

      =  !=  <>   >  >=  <  <=
      in 
      between and
      not
      and
      or
      is null
      is not null

      模糊查询： like  适用于字符串数据   _  %

      distinct

      order by  字段 ASC DESC

 

     聚合函数：sum()  count()  avg()  max()  min()

     分组:group by

     注意: group by后边的字段才能用在select后边

     select 字段 .... from 表名 where 条件 order by 。。 group by  。。 having

 

数据的完整性:保证表中的数据准确可靠

     实体完整性：
                 表中的一条记录对应一个实体，实体具备独一无二性，那么记录也应该是独一无二的

                 所以在创建表的时候就得保证表中每条记录必须是互不相同的

     实现实体完整性的三种方式:

                 主键：primary key   被设置为主键的字段上的值是不能重复的,不能为null，一个表只能有一个主键

   Unique(唯一约束)： 被设置为unique的字段，该字段上的值不能重复，但是可以为null

   AUTO_INCREMENT(自动增长):适合于整型字段，被设置为自动增长的字段上的值是由数据库来生成的 这个值从1开始，每次增加1

 

     域完整性：
             域：每个字段上的值都有一个取值范围，保证用户添加的数据在字段的取值范围内

             所以在创建表的时候就得保证域完整性

      create table tt(
          id int primary key,
   name varchar(20) not null,-- 默认name字段的值是可以为null的
                 sex varchar(4) default '男'
   )
     
      数据类型

      非空约束（not null）
     
      默认值约束(default)
         
     引用完整性：外键，一个表可以有多个外键

                foreign  key(字段名)  references 被引用的表(被引用的字段)

  数据库需要维护外键，会增加数据库开销，降低性能

   

  三个完整性都是为了保证表中数据的准确可靠。

  一张表对应同一类实体
  因为实体和实体之间有关系
  所以表和表之间有关系
  关系型数据库

  表和表之间的关系: 一对一，一对多，多对多

  多表查询：

  1：?合并结果集；
 
       UNION
       UNION ALL

-- UNION 会去除重复的记录
SELECT * FROM a
UNION
SELECT * FROM b

-- UNION all 不会去除重复的记录
SELECT * FROM a
UNION ALL
SELECT * FROM b

2：?连接查询

     内连接：  inner join

     外连接
        左外连接  left outer join
 右外连接  right outer join

3:子查询

4：自连接

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

package com.zqf;
import java.util.*;
public class Test{
 public static void main(String[] args) {
  Set<Person> set=new TreeSet<Person>();
  set.add(new Person("zhangsan",12));
  set.add(new Person("lisi",14));
  set.add(new Person("wanger",13));
  System.out.println(set);
 }
}
class Person implements Comparable<Person>{
 private String name;
 private int age;
 public String getName() {
  return name;
 }
 public void setName(String name) {
  this.name = name;
 }
 public int getAge() {
  return age;
 }
 public void setAge(int age) {
  this.age = age;
 }
 public Person(String name, int age) {
  super();
  this.name = name;
  this.age = age;
 }
 public Person() {
  super();
 }
 @Override
 public String toString() {
  return "Person [name=" + name + ", age=" + age + "]";
 }
 @Override
 public int compareTo(Person p) {
  //按照年龄
/*  if(this.age>=p.age) {
   return 1;
  }else {
   return -1;
  }
*/  
  //按照姓名
  int compareTo = this.name.compareTo(p.name);
  return compareTo;
 }
}