1. char        字符型        占2个字节
    2. bollen        布尔型        1个字节        true false
    3. short         短整型     2 
    4. int         整型          4 (整形默认)
    5. long         长整型     8 
    6. 一个字节8个比特位
    8.   ○ 十进制：数据以非0开头，例如：4，-15； 
    9.   ○ 八进制：数据以0开头，例如：054，012； 
    10.   ○ 十六进制：数据以0x开头，例如：0x11，0xAD00
    11.   ○ 二进制（是JDK1.7新增功能）:数据以0b开头,例如：0b101。
    13. float类型以F/f结尾，double类型以D/d结尾。如果浮点常量不带后缀，则默认为双精度常量
    15. ○ 自动转换的次序为：
    16.     byte-->short-->char-->int-->long-->float-->double
    17. ○ 强制类型转换格式为: 
    18.     变量 = (数据类型)表达式。      //注意：强制转换可能导致数据的失真。
    19.     出现各种类型数据的混合运算，系统将按自动转换原则将操作数转化为同一类型，再进行运算。
    20. 一个整数和一个浮点数进行运算，结果为浮点型。字符与整数的混合运算，字符转换为整数
    22. 设x=3,执行下面语句结果为true。       
    23.     System.out.println((x==3)||(x/0>2));     或运算符当前面为真不再计算后面
    24. 如果将代码改为：      
    25.     System.out.println((x/0>2)||(x==3)); 则运行时将产生算术运算异常，不能用x去除0。
    27. public class Test1 { 
    28.     public static void main(String[] args) {
    29.         int x=5;
    30.         if(x=0)
    31.             System.out.println("false");
    32.         else
    33.             System.out.println("ture");
    34.     }
    35. }     
    36. 编译错误！
    37. 原因：if条件只接受boolean类型的值（true或false），x=0是int类型不能隐式地转换为boolean类型。
    1. 输出：
    2.     1）print()方法：实现不换行的数据输出； 
    3.     2）println()方法：与上面方法的差别是输出数据后将换行。
    4.     3）printf()方法：带格式描述的数据输出。
    5.         %d代表十进制数
    6.         %f代表浮点数
    7.         %e代表科学表示法的指数位数（指数形式，默认6位小数：1.500340e+03）
    8.         %n代表换行符
    9.         %x代表十六进制数
    10.         %s代表字符串
    11.         %c 单个字符 
    12.         %% 输出百分号%
    13. 输入：
    14.     1、字符类型数据的输入 
    15.     利用标准输入流(System.in)的read()方法，可以从键盘读取字符，返回值为  int
    16.         char  c=(char)System.in.read()
    18.     2、字符串的输入 
    19.         1. 将键盘输入的数据看作字符流，利用InputStreamReader将从键盘输入的字节流数据转化为字符序列来识别。
    20.         2. 利用BufferedReader对字符流序列进行过滤，借助BufferedReader流对象提供的方法readLine()从键盘读取一个字符串。 
    21.             import java.io.*; 
    22.             public class InputString{ 
    23.               public static void main(String args[]) { 
    24.                 String s=“”;                                    必须赋初值，否则编译出错
    25.                 System.out.print ("Enter a String please: "); 
    26.                 try  { 
    27.                     BufferedReader in=  new BufferedReader(new InputStreamReader(System.in)); 
    28.                      s=in.readLine(); 
    29.                 } 
    30.                 catch (IOException e) {  } 
    31.                 System.out.println ("You've entered a String: " +s); 
    32.               } 
    33.             } 
    35.     3、整数和双精度数的输入 
    36.         通过上述字符串输入后将字符串转化
    37.               ○ Integer.parseInt(String s) ：    将数字字符串转化为整数 。
    38.               ○ Double.parseDouble(String s) ：    将字符串形式的数字数据转化为双精度数。 
    39.                   ○ 例如：
    40.                     ■ String x="123"；    int m= Integer.parseInt(x);  //m 的值为123
    41.                     ■ x="123.41"；        double n= Double.parseDouble(x) ; //n的值为123.41  
    43. java.util.Scanner类
    44.     1、import java.util.Scanner;
    45.     2、Scanner in=new Scanner(System.in);
    46.     3、   boolean hasNext()  ： 判是否有下一个数据
    47.           int nextInt()  ：读取整数
    48.           double nextDouble()  ：读取双精度数
    49.           String nextLine()  ：  读取一行字符串
    1. ● double random()                 产生0~1之间随机数，不包括0和1
    2. ● long round(double d)          四舍五入的整数 
    4. ● int abs(int i) 
    5. ● int max(int i1,int i2) 
    6. ● double ceil(double d)         不小于d的最小整数
    7. ● double floor(double d)        不大于d的最大整数 
    8. ● double random()                 产生0~1之间随机数，不包括0和1
    9. ● long round(double d)          四舍五入的整数 
    10. ● double log(double d) 
    11. ● double exp(double x) 
    12. ● double pow(double a, double b) 
    13. ● double sqrt(double a) 
    14. ● double cos(double d) 
    16. 例：三个数最大值          int c=Math.max(a,Math.max(b,c));
    17. 例：产生一个随机两位数        int a = 10 + (int)(90*Math.random()); 
    18.    产生[a,b]随机整数:     a+(int)(Math.random()*(b-a+1))
    1. 1、相同数据类型元素的集合； 
    2. 2、连续存放在内存之中； 
    3. 3、用数组名和位置（称为下标）表达
    5. 增强 for循环 访问数组
    6.     for (数组存储元素类型  循环变量名 : 数组名)  { 
    7.         循环体 
    8.     }   
    9. 例：for (int x:score){sum += x;}其中,x的取值随循环从score[0],score[1],…,score[9]变化。
    11. 一维：{
    12.     声明：int a[];或int []a;
    13.     创建空间：int score[] = new int[10]; 
    14.     创建并初始化:       ■ int score[ ] = {1,2,3,4,5,6,7,8,9,10};    
    15.                      ■ int score[ ]=new int[这里不能有大小] {1,2,3,4,5,6,7,8,9,10}; 
    16.     score.length 指数组score的长度。
    17.     String str;   str.length();字符串长度
    18.     }
    20. 二维：{
    21.     声明：int a[][]; 
    22.     创建空间：二维数组看作是数组的数组，不要求二维数组每一维的大小相同 
    23.         （1）直接为每一维分配空间，如：         
    24.             int a[][] = new int [2][3]; 
    25.         （2）从最高维开始，按由高到低的顺序分别为每一维分配空间。如：     
    26.             int a[][] = new int [2][];     a[0] = new int [3];     a[1] = new int [4]; 
    27.    长度：
    28.         要获取数组的行数     a.length 
    29.         通过某一行获取列数： a[1].length  a[2].length
    30.    创建并初始化:   
    31.         int a[][] = {{1,2,3},{4,5,6}};         
    32.         int b[][] = {{1,2},{4,5,6}}; }
    34. 例：二维数组动态创建
    35. public class ArrayOfArraysDemo2 { 
    36.   public static void main(String[] args) { 
    37.       int[][] aMatrix = new int[4][]; 
    38.       for (int i = 0; i < aMatrix.length; i++)  { 
    39.           aMatrix[i] = new int[i+1]; 
    40.           for (int j = 0; j < aMatrix[i].length; j++)  
    41.               aMatrix[i][j] = i + j; 
    42.          } 
    43.      for (int i = 0; i < aMatrix.length; i++) { 
    44.          for (int j = 0; j < aMatrix[i].length; j++)  
    45.                 System.out.print(aMatrix[i][j] + " "); 
    46.             System.out.println(); 
    47.     } 
    48.   }
    49.     /*
    50.     【运行结果】
    51.     0
    52.     1 2
    53.     2 3 4
    54.     3 4 5 6
    55.     */
    56. } 
    57. 例：求矩阵的最外一圈元素之和
    58. public class  Demo { 
    59.   public static void main(String[ ] args) { 
    60.       int [ ][ ]  a = new int[4][5]; 
    61.       int sum=0;
    62.      for (int i = 0; i < a.length; i++) { 
    63.          for (int j = 0; j < a[i].length; j++)  {
    64.                 a [i][j] = (int)(Math.random()*10);               
    65.                 System.out.print(a[i][j] + "\t"); 
    66.                 if  (i==0||j==0||i==a.length-1||j==a[0].length-1)
    67.                     sum += a[i][j];
    68.          }
    69.          System.out.println(); 
    70.       }  
    71.       System.out.println("sum= " +sum); 
    72.   }
    73. /*
    74. 7       9       3       7       8
    75. 8       1       5       2       8
    76. 4       2       1       5       4
    77. 1       1       1       2       6
    78. sum= 69
    79. */
    80. } 
    82. 因为是在堆中，所以new的时候jvm会自动给数组赋值。
    83. 1、int类型定义的数组，初始化默认是0
    84. 2、String类型定义的数组，默认值是null
    85. 3、char类型定义的数组，默认值是0对应的字符
    86. 4、double类型定义的数组，默认值是0.0
    87. 5、float类型定义的数组，默认值是0.0
    88. 6、boolean类型定义的数组，默认值是false
    90. Arrays类封装了对数组进行操作的一系列静态方法。
    91.     1. 利用Arrays类的sort方法可方便地对数组排序。 
    92.         例如：        java.util.Arrays.sort(a) ;  
    93.     2. 利用Arrays类的toString()方法可以将数组转化为字符串的形式。
    94.         例如：        System.out.print(java.util.Arrays.toString(a) );
    95.     3. 利用Arrays类的copyOf()方法实现数组的拷贝。
    96.         例如：        int[] b=Arrays.copyOf(a,3);
    97. {
    98.     import java.util.Random;
    99.     public class test7_5 {
    101.         public static void main(String[] args) {
    102.             {
    103.                 int[] a=new int[20];//整型数组
    104.                 String str="";//存放抽到的随机数
    106.                 for(int i=1;i<=20;)
    107.                 {
    108.                     int num=10+(int)(Math.random()*81);//Math.random()是用于随机生成一个［0.0, 1.0)
    109.                     String S=num+","; //随机数之间用逗号隔开
    110.                     if(str.indexOf(S)==-1) //是否已经存在该数
    111.                     {
    112.                         str=str+S; //拼接字符串
    113.                         i++;
    114.                     }
    115.                 }
    116.                 String[] str1=str.split(",");//以逗号为分隔符，存入str1
    118.                 //将字符串类型转为整型并输出
    119.                 System.out.println("随机函数产生 20 个 10 ~ 90 之间的不重复整数为：");
    120.                 for(int i=0;i<str1.length;i++) {
    121.                     a[i]=Integer.parseInt(str1[i]);
    122.                     System.out.print(a[i]+" ");
    123.                 }
    124.                 System.out.println();
    126.                 java.util.Arrays.sort(a);            排序
    127.                 System.out.println("数组的内容按由小到大的顺序输出为：");
    128.                 for(int i=0;i<a.length;i++)
    129.                     System.out.print(a[i]+" ");
    130.             }
    131.         }
    132.     }
    133. }
    1. 属性初始化执行次序：定义时赋值→ 初始代码块 → 构造方法
    2. 初始化：{
    3. 1、定义属性成员时初始化：
    4.     public class Point {private int x=10;}
    5. 2、初始化块来设置对象的初值：
    6.     public class Point {  
    7.         private int x;   默认为0
    8.         {   //初始化代码块
    9.            x = 20;
    10.         }
    11.     }
    12. 3、构造方法： 
    13.     public Point(int x1, int y1) {
    14.         x = x1;y = y1;
    15.     }
    17. 例：
    18. public class A {
    19.    int v=0;         
    20.    {   v=v+1;   }    //初始化块
    21.    public A( ) {   }
    22.    public A(int x ) {   v=x;   }
    23.    public static void main(String args[ ]) {
    24.          A  m1 = new A(25); 
    25.          System.out.println(m1.v);        25
    26.          A  m2 = new A(); 
    27.          System.out.println(m2.v);      1  
    28.     }
    29. }
    30. }
    32. static修饰的属性：{
    33. 访问：
    34.     在本类中直接访问：count 
    35.     通过类名访问：User.count 
    36.     通过类的一个对象访问，如：x1.count 
    38. 静态初始化代码的执行是在main方法执行前完成。
    39. 初始化代码块：对象初始化，创建对象时，系统先调用类里定义的初始化块。在构造方法之前执行。
    40. 静态初始化代码块：又称类初始化代码块，对类进行初始化，在初始化代码块之前执行，其不能对实例变量进行初始化。
    41. 区别：
    42.     初始化代码块创建对象时执行，每次创建对象都会执行一次；（main之后）
    43.     静态初始化代码块在加载类时会执行，且只执行一次（main之前）
    44. 例：
    45. class test {
    46.    static int x=5;
    47.    int y=5;
    48.    static { x+=10; }
    49.    {y+=10;}
    50.    public static void main(String args[ ]) {
    51.       System.out.println("x="+x);
    52.        x+=20;
    53.      test a=new test();
    54.       System.out.println("x="+a.x);
    55.       System.out.println("y="+a.y);
    56.       a.y+=20;
    57.      test b=new test();
    58.       System.out.println("y="+b.y);
    59.    }
    60.    static { x=x-5; }            注意 
    61. /*
    62. x=10
    63. x=30
    64. y=15
    65. y=15
    66. */
    67. }
    68. 例：静态空间与对象空间的对比
    69. class TalkPlace {  
    70.     static String talkArea=""; 
    71. } 
    72. public class User {
    73.     static int count=0;              //类变量
    74.     String username;   
    75.     int age;     //实例变量
    76.     public User(String name,int yourage) {
    77.         username=name;      
    78.         age=yourage;
    79.     }
    80.       /* 方法log通过静态变量记录调用它的次数 */
    81.     void log( ) {  
    82.         count++;      //直接访问本类的静态变量 
    83.         System.out.println("you are no "+count+" user");
    84.     }
    85.     void speak(String words) {  /*  向讨论区发言 */
    86.         TalkPlace.talkArea += username + "说:"+words+"\n"; 
    87.     }  
    88.     public static void main(String args[ ]) {
    89.         User x1 = new User("张三",20); 
    90.         x1.log( );
    91.         x1.speak("hello");
    92.         User x2 = new User("李四",16); 
    93.         x2.log( );
    94.         x2.speak("good morning");
    95.         x1.speak("bye");
    96.         System.out.println("---讨论区内容如下：");
    97.         System.out.println(TalkPlace.talkArea);
    98.     }
    99. }
    101. }
    102. static修饰的方法：{
    103.     1、用static修饰的方法称为静态方法，也叫类方法
    104.     2、在static方法中只能访问类变量和其它static方法
    105.     3、在static方法中绝不能直接访问任何归属对象空间的变量或方法 
    106.     例：public static void clearCount(){
    107.                count=0;        //访问类变量
    108.                age=0;        //不允许
    109.        }        不能访问其他非静态变量
    110.         public class findPrime {
    111.             public static boolean prime(int n){
    112.                 for (int k=2;k<=Math.sqrt(n);k++) 
    113.                     if ( n % k==0)
    114.                         return false;  
    115.                  return true; 
    116.             }
    117.     1、     public static void main(String args[]) {
    118.                 for (int m=10;m<=100;m++) 
    119.                     if ( prime(m))
    120.                         System.out.print(m+" , ");
    121.             }
    122.     2、     public static void main(String args[]) {               
    123.                 findPrime  x=new findPrime();
    124.                 for (int m=10;m<=100;m++)
    125.                     if ( x.prime(m) )
    126.                         System.out.print(m+" , ");
    127.             }    如果将prime方法设计为非静态方法    
    128.         }              访问静态和非静态方法
    129. 思考题：
    130.     public class Test{
    131.         long a[ ] = new long[10];
    132.         public static void main ( String args[] ){
    133.              System.out.println (a[6]);      出现编译错误，Test x=new Test();System.out.println ( x.a[6]);或static long a[ ] = new long[10];
    134.         }
    135.     }
    136. }
    137. 理解this:{
    138.     this ---出现在类的实例方法、初始化代码块、构造方法中，用来代表使用该方法的当前对象的引用。
    139. 用this作为前缀，访问当前对象的属性或方法。
    140. 1）使用this可以区分当前作用域中同名的不同变量。            
    141.     private int x, y;  // 属性           
    142.     public Point(int x, int y) {  //构造方法                
    143.         this.x = x;
    144.         this.y = y;               
    145.     }
    146. 2）把当前对象引用作为参数传递给另一个方法。               
    147.     如： p.distance(this); 
    148. 3）一个构造方法中调用同类的另一个构造方法。         
    149.     public Point() { this(0,0); }
    150. 例：
    151.     public class Point {
    152.         private int x, y;  
    153.         public Point(int x, int y) { 
    154.             this.x = x; this.y = y;
    155.         }
    156.         public Point() {          无参构造方法
    157.             this(0,0);            用this调用本类的另一构造方法
    158.         }
    159.        public double distance(Point p) { 
    160.             return Math.sqrt((this.x-p.x)* (x-p.x) + (y-p.y)*(y-p.y));
    161.        }
    162.         /*以下两个方法在利用上面方法求距离（演示概念）*/
    163.         public double distance2(Point p) { 
    164.                 return  p.distance(this);   //p到当前点的距离 
    165.         } 
    166.         public double distance3(Point p) { 
    167.                 return this.distance(p); //调用当前对象另一方法
    168.                ……
    169.         }
    170.     }
    171. }
    1. 继承意味着什么?什么是变量的隐藏?
    2.     1、可以实现方法重写(这样可以实现运行时多态性)。继承允许我们重用代码，它提高了Java应用程序的可重用性。
    3.     2、如果子类中定义了与父类同名的属性，在子类中将隐藏来自父类的同名属性变量。
    5. 子类构造方法与父类构造方法有何联系?
    6.     1、super来调用父类的构造方法，必须是子类构造方法的第1条语句！super.name=aname; 通过super关键字来访问父类中的name属性
    7.     2、子类在自己定义构造方法中如果没有用super明确调用父类的构造方法，则在创建对象时,首先自动执行父类的无参构造方法,然后再执行自己定义的构造方法。
    8.         注意：如果子类构造函数没有用父类构造方法且父类中无无参构造函数会出现编译出错
    9.         例：{
    10.                 class parent  { 
    11.                     String my; 
    12.                     public parent(String x) { my=x; } 
    13.                 } 
    14.                 public class subclass extends parent {  
    15.                     subclass x=new subclass();
    16.                 } 
    17. }
    19. 子类this：{
    20. 【注意】使用 this 查找匹配的方法时首先在本类查找，找不到时再到其父类和祖先类查找；
    21.        使用 super 查找匹配方法时，首先直接到父类查找，如果不存在，则继续到其祖先类逐级往高层查找。
    22. }
    24. 多态性：{
    25. 1、（编译时多态）同一类中（重载）：同一类中允许多个同名方法，通过参数的数量、类型的差异进行区分。编译时确定调用哪个方法。
    26. 2、（运行时多态）子类对父类方法的重新定义（方法覆盖）：方法名、返回值和参数形态完全一样。在运行时确定调用哪个方法。
    27. 方法覆盖有以下问题值得注意：6.2
    29. 方法重载与覆盖的区别
    30.     1. 重载是同一个类中定义了多个同名的方法，表示方法间的关系，是水平关系；覆盖是子类和父类之间的关系，是垂直关系。
    31.     2. 重载是多个方法之间的关系；覆盖是由一个方法或只能由一对方法产生关系。 
    32.     3. 重载要求参数列表不同；覆盖要求参数列表相同。
    33.     4. 重载是根据调用时的实参表与形参表选择方法体；覆盖是根据对象类型来调用方法体。
    35. 访问继承的成员：{
    36.     (1)继承关系中方法的继承与父类属性隐藏{
    37.         class parent{
    38.             int x=100;
    39.             void m() { 
    40.                 System.out.println(x);
    41.             }
    42.         }
    43.         public class child extends parent{
    44.             int x=200;
    45.             public static void main(String[] args) {
    46.                 child a=new child();
    47.                 a.m();
    48.                 System.out.println(a.x);
    49.             }
    50.         }
    51.         运行结果:
    52.         100
    53.         200
    54.     }
    55.     (2)继承关系中方法的覆盖{
    56.         class parent{
    57.             int x=100;
    58.             void m() {
    59.                 System.out.println(x);
    60.             }
    61.         }
    62.         public class child extends parent{
    63.             int x=200;
    64.             void m() {
    65.                 System.out.println("x="+x);
    66.             }
    67.             public static void main(String[] args) {
    68.                 child a=new child();
    69.                 a.m();
    70.                 System.out.println(a.x);
    71.             }
    72.         }
    73.         运行结果:
    74.         x=200
    75.         200  
    76.     }  
    77.     (3)父类引用子类对象{
    78.         class parent{
    79.             int x=100;
    80.             void m() {
    81.                 System.out.println(x);
    82.             }
    83.         public class child extends parent{
    84.             int x=200;
    85.             void m() {
    86.                 System.out.println("x="+x);
    87.             }
    88.             public static void main(String[] args) {
    89.                 parent a=new child();
    90.                 a.m();
    91.                 System.out.println(a.x);
    92.             }
    93.         } 
    94.         运行结果:
    95.         x=200
    96.         100
    97.         }
    98.     }        重要，调用的方法是子类方法，属性是父类属性
    99.     }   
    100. }
    102. 访问继承的成员（重要）{
    103.     class SuperShow {
    104.         int y = 8;          // 父类SuperShow的y属性
    105.         int m = 2;
    106.         void show() {       //父类SuperShow的show方法
    107.             System.out.println("sup.show,y="+y);
    108.         }
    109.     }
    110.     public class ExtendShow extends SuperShow {       每个子类对象有4个属性:y、z、super.y、m
    111.         int y = 20;     // 子类ExtendShow的y属性
    112.         int z = 1;
    113.         void show() {  // 子类ExtendShow的show方法
    114.             System.out.println("ext. show,y="+y);
    115.         }
    116.         public static void main(String args[]) {
    117.             ExtendShow b = new ExtendShow();
    118.             SuperShow  a = b;
    119.             System.out.println("ext.y=" + b.y);      20
    120.             System.out.println("sup.y=" + a.y);      8
    121.             b.show();                                  y=20
    122.             a.show();                                 y=20
    123.             System.out.println("z="+b.z+",m="+b.m); z=1,m=2
    124.         }
    125.     }
    126.     运行结果：
    127.     ext.y=20
    128.     sup.y=8
    129.     ext. show,y=20
    130.     ext. show,y=20
    131.     z=1,m=2
    132. }        //调用的方法是子类方法，属性是父类属性
    133. 例：{
    134.     例1：
    135.     class Test5 {
    136.         int k = 8;
    137.         public void doSome() {
    138.             System.out.println("k1="+k);
    139.         }
    140.     }
    141.     class Sub extends Test5 {
    142.         int k = 66;
    143.         public void doSome() {
    144.             k=k-2;
    145.             System.out.println("k2="+k);
    146.         }
    147.         public static void main(String args []) {
    148.             Test5 obj = new Sub();
    149.             obj.doSome();
    150.             System.out.println("k3="+obj.k); 
    151.         }
    152.     }
    153.     运行结果：
    154.     k2=64
    155.     k3=8
    156.     思考：
    157.     (1)将obj定义为子类引用变量如何?（Test5->Sub)
    158.     运行结果：
    159.     k2=64
    160.     k3=64  
    161.     (2) 将子类的doSome()方法删除又如何？
    162.     k1=8
    163.     k3=8
    165.     例2：
    166.     class exSuper {
    167.         public void func(String p, String s) {
    168.             System.out.println(p);
    169.         }
    170.     }
    171.     public class test extends exSuper {
    172.         public void func(String p, String s) {
    173.             System.out.println(p + " : " + s);
    174.         }
    175.         static public void main(String arg[ ]) {
    176.             exSuper e1 = new exSuper( );
    177.             e1.func("hello1", "hi1");
    178.             exSuper e2 = new test();
    179.             e2.func("hello2", "hi2");
    180.         }
    181.     }
    182.     运行结果：
    183.     hello1
    184.     hello2 : hi2
    185. }
    187. Object类：{
    188.     ● public boolean equals(Object obj) :
    189.         //该方法本意用于比较两个对象的封装的数据是否相等；而比较运算符“==”在比较两对象变量时，只有当两个对象引用指向同一对象时才为真值。
    190.         在Object类中，equals方法是采用“==”运算进行比较（地址比较）；若表示对象的数据比较，要重写equals()方法；
    191.     ● public String toString():            该方法返回对象的字符串描述；
    192.     ● public final Class getClass():    返回对象的所属类；
    193.     ● protected  void  finalize():         该方法Java垃圾回收程序在删除对象前自动执行。
    194.     {
    195.         public class Point {
    196.         private int x, y;
    198.         public Point(int x, int y) {
    199.             this.x = x;
    200.             this.y = y;
    201.         }
    203.         public boolean equals(Point p) {
    204.             return (x == p.x && y == p.y);
    205.         }
    207.         public String toString() {
    208.             return "点:" + x + "," + y;
    209.         }
    210.         public static void main(String arg[]) {
    211.             Point x=new Point(4,3);
    212.             System.out.println("x="+x);
    213.             System.out.println( x.equals(new Point(4,3)) );
    214.         }
    215.     }
    216.         运行结果：
    217.         x=点:4,3
    218.         true
    219.         【思考】
    220.         1、观察有无toString()方法时程序运行结果的变化。
    221.         无toString()运行结果：
    222.         x=Point@404b9385
    223.         true
    224.         2、观察有无equals(Point p)方法程序运行结果的变化。
    225.         无equals(Point p)运行结果：
    226.         x=点:4,3        （没有重写equals方法则是引用的比较）
    227.         false
    228. }
    229.     {
    230.         public class IsEqual {
    231.         int x;
    232.         public IsEqual(int x1) {
    233.             x=x1;
    234.         }
    235.         public static void main(String a[ ]) {
    236.             IsEqual m1=new IsEqual(4);
    237.             IsEqual m2=new IsEqual(4);
    238.             IsEqual m3=m2;
    239.             m3.x=6; //注释后呢？
    240.             System.out.println("m1=m2 is "+(m1==m2));
    241.             System.out.println("m2=m3 is "+(m2==m3));
    242.             System.out.println("m1.x==m2.x is "+(m1.x==m2.x));
    243.             System.out.println("m1.equals(m2)="+m1.equals(m2));
    244.         }
    245.     }
    246.         运行结果：
    247.         m1=m2 is false
    248.         m2=m3 is true
    249.         m1.x==m2.x is false
    250.         m1.equals(m2)=false
    252.         m3.x=6; //注释后呢？
    253.         运行结果：
    254.         m1=m2 is false
    255.         m2=m3 is true
    256.         m1.x==m2.x is true
    257.         m1.equals(m2)=false
    258.     }
    259. }
    261. 访问控制修饰符：{
    262.                 同一类中     同一包中     不同包的子类中     其他 
    263.     private         Yes               
    264.     默认            Yes         Yes          
    265.     protected       Yes           Yes             Yes     
    266.     public          Yes           Yes             Yes          Yes 
    267. }
    269. final修饰符：{
    270.     ● final作为类修饰符                ----最终类 （不能有子类）
    271.     ● 用final修饰方法                 ----不能被子类重新定义 
    272.     ● 用final定义常量 （必须被初始化）  ----只能赋值一次      
    273.     【注意】 如果将引用类型的变量标记为final,那么该变量固定指向一个对象，但可以改变对象内的属性值。 final意味着不能改变，到此为止！
    274.     {
    275.         public final class test {
    276.             public static int totalNumber=5;
    277.             public final int id; //error  与普通属性变量不同的是，系统不会给常量赋默认初值.
    278.             public int weight;
    279.             public test(int weight) {
    280.                 id=totalNumber++;
    281.                 this.weight=weight;
    282.             }
    283.             public static void main(String args[ ]) {
    284.                 final test t=new test(5);
    285.                 t.weight=t.weight+2;
    286.                 t=new test(4);               不允许      
    287.                 t.id++;                        不允许
    288.             }
    289.         }
    290.     }
    291. }
    293. 对象引用赋值转换：{
    294.     1. 允许将子类对象赋值给父类引用 。
    295.     2. 将父类引用赋值给子类变量时要进行强制转换，强制转换在编译时总是认可的，但运行时的情况取决于对象的值。
    296.         1. Object m = new String("123");    // 允许，父类变量引用子类对象      
    297.         2. String y = m;                    // 不允许      
    298.         3. String y = (String) m;            // 强制转换，编译允许，且运行没问题      
    299.         4. Integer p =  (Integer) m;        // 强制转换，编译允许，但运行时出错
    300.            Integer p =  Integer.parse((String) m);
    301.            {
    302.                    public class test{
    303.                         static void m(double x) {
    304.                             System.out.println("m(double):" + x);
    305.                         }
    306.                         static void m(Object obj) {
    307.                             System.out.println("m(Object):" + obj );
    308.                         }
    309.                         public static void main (String args[]) {
    310.                             m("hello");
    311.                             m(5);
    312.                         }
    313.                     }
    314.                     运行结果：
    315.                     m(Object):hello
    316.                     m(double):5.0
    317.            }
    318. }
    1. public String toString() {            父类toString
    2.      return  "点：" + x + ","+ y;
    3. }        
    4. public String toString() {            子类重写toString
    5.     return super.toString() + "颜色： " +c;         super代表父类对象的引用，用super调用父类成员
    6. }        
    8. public void display(){
    9.         System.out.print("学号：："+No);
    10.         System.out.print("  姓名：："+Name);
    11.         System.out.println("  年龄：："+Age);
    12. }
    14. public String toString(){
    15.     return "学号：："+No+"  姓名：："+Name+"  年龄：："+Age;
    16. }
    1. String的特点：
    2.     1.为不可变对象，一旦被创建就不能修改它的值；
    3.     2.String类是final类型不可被继承；
    4. StringBuffer的特点：
    5.     1.它是一个可变的对象，当你需要修改其内容的时候，可以通过调用其方法进行修改。
    6.     2.不能通过赋值符号对他进行赋值.。
    7.     3.字符串连接操作中StringBuffer的效率要比String高
    9. 比较字符串：
    10.     String值比较：{
    11.         int compareTo(String anotherString)        
    12.         boolean equals(Object anObject)     重写equals方法，是值比较    
    13.         {
    14.             {    String s1="Hello!World"; 
    15.                 String s2="Hello!World";
    16.                 boolean b1=s1.equals(s2);        true
    17.                 boolean b2=(s1==s2);            true,Java存储优化策略，字符串常量只存储一份
    18.             }
    19.             {    String s1="Hello!World"; 
    20.                 String s2=new String("Hello!World");            创建一个新字符串
    21.                 boolean b1=s1.equals(s2);        true
    22.                 boolean b2=(s1==s2);            false
    23.             }
    24.         }
    25.         boolean equalsIgnoreCase(String anotherString)}
    26.     引用比较：“==”
    27.     StringBuffer:继承的Object的equals方法，引用比较
    28. split分离字符串：{
    29.     格式：public String[] split(String regex) ；
    30.         str="boo:and:foo:bye"；str.split(":")的结果为：{ "boo", "and", "foo" , "bye" }
    31.         注意，参数串代表一个正则表达式的匹配模式，分隔符如果是+、*等符号时，要进行转义处理，例如分隔符为“+”，要写成"\\+"的正则式。        
    32.         String x= "1+2+4+5+8"; x.split(" \\+ ")的结果为{" 1 ", " 2 ", " 4 ", " 5 ", " 8"  }
    33.     应用：
    34.         String str = "Java is an Object Oriented programming language";
    35.         String[] str2 = str.split(" "); //以空格为分隔符分离字符串
    36. }
    38. 写程序的运行结果{
    40. public class Foo { 
    41.     public static void main (String [ ] args) { 
    42.         StringBuffer a = new StringBuffer("A"); 
    43.         StringBuffer b = new StringBuffer("B"); 
    44.         operate(a,b); 
    45.         System.out.println(a + "," +b); 
    46.      }
    47.     static void operate (StringBuffer x, StringBuffer y) { 
    48.           x.append(y); 
    49.           y = x; 
    50.    }
    51.  }
    52. 运行结果：AB,B
    54. public class Foo { 
    55.     public static void main (String [ ] args) { 
    56.         String a = new String("A"); 
    57.         String b = new String("B"); 
    58.         operate(a,b); 
    59.         System.out.println(a + "," +b); 
    60.      }
    61.     static void operate (String x, String y) { 
    62.           x=x+y; 
    63.           y = x; 
    64.    }
    65.  }
    66. 运行结果：A,B}
    1. 4. 基本类类型和包装类有什么关系?包装类和基本数据类型之间有什么区别?
    2.     1、声明方式不同
    3.         基本类型不适用new关键字，而包装类型需要使用new关键字来在堆中分配存储空间；
    4.     2、存储方式及位置不同
    5.         基本类型是直接将变量值存储在堆栈中，而包装类型是将对象放在堆中，然后通过引用来使用；
    6.     3、初始值不同
    7.         基本类型的初始值如int为0，boolean为false，而包装类型的初始值为null
    8.     4、使用方式不同
    9.         基本类型直接赋值直接使用就好，而包装类型在集合如Collection、Map时会使用到。
    10.     5、包装类都是继承Number 接口实现Compareble 接口的
    12. 包装类优点：
    13.       提供了一系列实用的方法
    14.       集合不允许存放基本数据类型数据，存放数字时，要用包装类型
    15. 包装类缺点：
    16.     由于每个值分别包装在对象中，所以ArrayList<Integer>的效率远远低于int[]数组。（应该用其构造小型集合，其原因是程序员操作的方便性要比执行效率更加重要）
    18. 补充：
    19.     1、int 类型不能赋值为null（默认值为0），包装类型Integer可以为null（默认值为null）
    20.     2、当int中的数值 与 integer 中的数值一致的时候， 使用 “==”  进行比较，结果为true
    21.     3、如果两个都是new的Integer相比较也是相等的
    23. 5. 为什么要使用包装类?
    24.     我们知道Java是一个面相对象的编程语言，基本类型并不具有对象的性质，为了让基本类型也具有对象的特征，
    25. 就出现了包装类型（如我们在使用集合类型Collection时就一定要使用包装类型而非基本类型），它相当于将基本类型“包装起来”，
    26. 使得它具有了对象的性质，并且为其添加了属性和方法，丰富了基本类型的操作。
    27.     另外，当需要往ArrayList，HashMap中放东西时，像int，double这种基本类型是放不进去的，
    28. 因为容器都是装object的，这是就需要这些基本类型的包装器类了。
    31. 1、int转Integer
    32.     int i = 0;  
    33.     Integer ii = new Integer(i);
    34. 2、Integer转int
    35.     Integer ii = new Integer(0);  
    36.     int i = ii.intValue();

    https://www.yuque.com/shaonian-8joxb/pvi3zw/qipn34#qbimZ

    1. 抽象类abstract通过继承实现extends
    2. 格式：abstract class 类名称 {     
    3.     成员变量；     
    4.     方法（）{……}       //一般方法     
    5.     abstract 方法（）；  //抽象方法 
    6. } 
    7. abstract class Shape {  //定义抽象类  
    8.        abstract public double area();  //抽象方法
    9.  } 
    10. class Triangle extends Shape {  //定义三角型
    11.     private double a, b, c;
    12.     public Triangle(double a, double b, double c) {
    13.         this.a = a;
    14.         this.b = b; 
    15.         this.c = c;    
    16.     }
    17.     public double area(){
    18.         double p = (a + b +c) / 2;
    19.         return Math.sqrt(p * (p - a) * (p- b) * (p- c));
    20.     }
    21. }
    22.     ● 在抽象类中可以包含一般方法和抽象方法。
    23.     ● 抽象类表示的是一个抽象概念，不能被实例化为对象。
    24.     ● 抽象类具体应用时需要继承。
    25.     ● 继承后抽象类的方法都必须全部实现。
    27. 接口interface通过implements实现
    28. 格式：[public] interface 接口名 [extends 父接口名列表]  { 
    29.         [public] [static] [final] 域类型 域名 = 常量值 ;
    30.         [public] [abstract] 返回值 方法名(参数列表) [throw 异常列表]；//别忘了默认也是这些修饰！
    31.     }
    32. interface Copyable { 
    33.     //[public] Object copy ();默认为public
    34.     Object copy ();
    35. }
    36. class Book implements Copyable  {
    37.    String book_name;              // 书名
    38.    String book_id;                // 书号
    39.    public Book(String name ,String id)  { 
    40.       book_name = name; 
    41.       book_id = id;
    42.    }
    43.    public Object copy () {             //public 一定要!
    44.    //这里是否可为Book类型？返回值为子类Book时，可改为Book  
    45.       return new Book(book_name , book_id);
    46.    }
    47.     //实现接口的类要将接口带来的抽象方法覆盖！
    48.    …
    49.       public String toString(){
    50.           return  super.toString()+" ,书名:"+book_name+",书号="+book_id;
    51.    }
    52. }
    53.     ● 声明接口可给出访问控制符；
    54.     ●  一个接口还可以继承多个父接口，父接口间用逗号分隔。 
    55.     ● 系统默认接口中所有属性的修饰都是public static final； 
    56.     ● 系统默认接口中所有方法的修饰都是public abstract。
    57.     ● ● ● 一个类可以实现多个接口。在类的声明部分用implements关键字声明该类将要实现的接口，接口间用逗号分隔；
    58.     ●  如果实现某接口的类不是抽象类,则该类必须实现指定接口的所有抽象方法； 
    59.     ● ● ● 接口的抽象方法的访问限制符默认为 public,在实现时要在方法头中显式地加上public修饰。
    1. 1、的输入输出类：
    2.     InputStream    OutputStream 面向字节，处理非文本文件
    3.     Reader  Writer 面向字符
    4.     File
    6. 2、步骤：
    7.     1. 创建流对象
    8.     2. 用方法从流输入数据
    9.     3. close( )关闭流
    11. 3、面向字节{
    12.     public int read() ：读一个字节 
    13.   1.  
    14.     FileInputStream infile = new FileInputStream(args[0]); 
    15.     int byteRead = infile.read();  以字节为单位访问
    16.     while (byteRead!=-1) { 
    17.         System.out.print((char)byteRead); 
    18.         byteRead = infile.read();
    19.     } 
    20.   2.
    21.     FileInputStream infile = new FileInputStream(args[0]);         从命令行获取要显示的文件名
    22.     BufferedInputStream buin=new BufferedInputStream(infile);   创建输入流
    23.     byte[] buffer=new byte[64];
    24.     int byteRead = buin.read(buffer);
    25.     while (byteRead!=-1) 
    26.     {   //判断是否读到文件的末尾
    27.         String str=new String(buffer,0,byteRead);   读取的字节转换为字符
    28.         System.out.print(str);
    29.         //System.out.print((char)byteRead);
    30.         byteRead = buin.read(buffer);               read（）方法读到文件结尾返回-1，读取文件时一个一个字节读入
    31.     }
    32.     buin.close(); 
    34. 输出：
    35.  1.  
    36.     FileOutputStream file = new  FileOutputStream("x.dat");        创建一个文件输出流，文件不存在则自动生成
    37.     DataOutputStream out=new  DataOutputStream(file);             对FileOutputStream包装，创建一个DataOutputStream流，利用该流向文件写入各种类型的数据
    38.     out.writeInt(n);     DataOutputStream的writeInt方法，写入整数
    39.     out.close();
    40. }
    41. 4、面向字符{
    42.   1.
    43.     LineNumberReader  in=new LineNumberReader(new FileReader("AddLineNo.java"));        从一个文本文件中读取数据加上行号后显示
    44.     String  x= in.readLine();        利用LineNumberReader的readLine()方法从文件逐行读取，末尾返回null
    45.   2.  
    46.     FileReader in = new FileReader("test13_4.java");  （单个字符读）
    47.     int charRead = in.read();
    48.     System.out.print((char) charRead);
    49.   3.  
    50.     BufferedReader in = new BufferedReader(new FileReader("test13_4.java"));
    51.     String x = in.readLine();
    53. 输出    
    54.   1.
    55.     FileWriter out=new FileWriter("charset.txt ");
    56.     for(int i=32;i<126;i++)
    57.         //.write(i);    输出乱码
    58.         out.write(Integer.toString(i));        整型数字转换为字符串
    59. 读入并加上行号输出：{
    60.     FileReader file= new FileReader("AddLineNo.java"); 
    61.     FileWriter out=new FileWriter("target.txt");
    62.     LineNumberReader  in=new LineNumberReader(file);
    63.     while (true) 
    64.     {
    65.         String x= in.readLine();
    66.         if (x == null) 
    67.             break;
    68.         else
    69.             out.write(in.getLineNumber()+":"+x+"\r\n");
    70.     }
    71.     out.close();
    72.     }        
    73. }
    74. 5、随机文件读写{
    75.     BufferedReader in=new BufferedReader(new InputStreamReader(System.in));            输入框输入
    76.     String s=in.readLine();
    77.     RandomAccessFile out=new RandomAccessFile(“java.log”,”rw”);
    78.     out.seek(myFile.length());   //将指针定到文件尾
    79.     out.writeBytes(s+”\n”);      //写入数据
    80.     out.close();
    81. }
    82. 6、对象串行化        ObjectOutputStream    &&        ObjectInputStream    {
    83.     1、写入文件
    84.         ObjectOutputStream out=new ObjectOutputStream(new FileOutputStream("storedate.dat"));
    85.         out.writeObject(new Date());
    86.         out.writeObject("hello world");
    87.         System.out.println("写入完毕");
    89.     2、读文件并显示
    90.         ObjectInputStream in=new ObjectInputStream(new FileInputStream("storedate.dat"));
    91.         Date current=(Date)in.readObject();
    92.         System.out.println("日期："+current);
    93.         String str=(String)in.readObject();
    94.         System.out.println("字符串:"+str);
    95. }