字符类型和控制语句、函数、懒汉、饿汉式

时间：2015-02-21 09:45:44 阅读：273 评论：0 收藏：0 [点我收藏+]

1. 小数默认为double类型。


2. 逻辑运算符：&&，||，！，&，|，^


3. 位运算：
     & ，|，^，~，《《，》》，》》》


a^b^b = a(得到本身)


位运算是最快的运算方法




两个数值的调换位置的方法：
     1.设置一个变量
          int a = 1,b  = 2,c;
               c = a; a = b; b = c;
     2.直接通过相加减我完成
          int a  = 1,b = 2;
          a = a + b;
          b = a - b;
          a = a - b;
     3. 通过^来完成
          int a = 1,b = 2;
          a = a ^b;
          b = a ^ b;
          a = a ^b;
                
三元运算符：
     变量 = （条件表达式）？表达式1：表达式2；
          好处：简化if else 
          弊端：表达式中一定要 有返回值；
switch（x） 中的X可以是 byte，short ，chart ，int


public class TestSwitch{
     public static void main(String args[]) {
          int a = 0;
          switch(a){
              
               default :
               System.out.println("default"+a);         
              
               case 1:
                    System.out.println("     case 1"+a);
                    //break;
                   
               case 2:
                    System.out.println("-     case 2"+a);
                  break;
                             
               case 3:
                    System.out.println("     case 3"+a);
                    break;
               
          case 4:
               System.out.println("     case 4"+a);
               break;                                                                     
          }
     }
}



     

输出的结果为：default 0

                        case1 0

                         case2 0

可以知道这个执行的顺序是：

     先是在case中进行判断，假如没有的话，就执行default（后面的语句），假如第一句是default的话

     那么后面的case语句不进行判断也还会执行，知道碰到break关键字才退出。

if与switch的区别：

     区间判断用 if

     确定的数值、只不多用 switch（效率也会高点），其他用if

     JDK1.7 可以对字符串进行判断，JDK1.5可以对枚举进行判断

流程控制语句：
          1. break ：应用范围:选择结构和循环结构。
          
          2. continue： 应用于循环结构


     注意：a. 两个语句离开了应用是没有意义的。
               b. 这两个语句单独存在 下面都不可以有语句，因为不会执行。
               c. continue是结束本次循环继续下次循环。
               d. 标号的出现，可以让两个语句作用指定的范围。


          eg：


w:for(int i = 0; i < 4; i ++){]
     q:for( int j = 0 ; j < 5 ; j ++){
          continue / break    w/q;
     }
}

----------------------------------------------

函数：
     函数的特点：
          1.增强了代码的复用性。
          2. 函数只有呗掉用的时候才会被执行。
          3. 返回值为void时候，那么return语句如果在最后一句可以省略不写。因为系统会自动添加。
     注意：
          1. 函数只能调用函数，不可一在函数内部定义函数。
          2. 定义函数时，函数的结果返回给调用者，交由调用者处理。
     如何定义一个函数？
          1. 既然函数是一个独立的功能，那么该功能的运算结果是是什么先明确。
                    明确函数的返回类型。
          2. 在明确的定义该功能的过程中是否需要未知的内容参与运算。
                    明确函数的参数列表。
函数的重载：
     1. 在同一个类中，允许在一个以上的同名函数，
               只是他们的参数个数或者是参数类型不同（顺序不同也算）即可。
重载的特点：
       2. 与返回的类型无关，只看参数列表。
什么时候该用重载呢？
       1. 想实现相同的功能，但是参加函数运算的参数不同，那么就应该用重载。
数组：
     1.同一种类型的数据集合，其实数组就是一个容器。


数组的排序的方式：
     1. 选择排序：选择一个固定的点和其他的元素进行排序。


     2. 冒泡排序：相邻的两个元素进行比较，如果符合条件就互换位置。


查找：
     1.二分查找（折半查找）：查找的数组是有序的。
     2. 插入一个数据到数组中，用二份查找的方式先找到这个位置，再插入。
----------------------------------------示例代码--------------------------------------------
package xyxy.sjxy.day004;

public class SortArr{
          public static void main(String args[]){
              int [] arr = new int[]{4,5,2,6,8,9,0};
                  sort1(arr);
                  //(arr );
                  //sort2(arr );
                  //sysArr(arr );
              int position =   insertPostion(arr,0);
             System. out.println(position);
                  sysArr(arr);
             }
              //选择排序
          public static void sort1(int[] arr){
                  for(int i = 0; i < arr.length - 1; i ++){
                           for(int j = i + 1; j < arr.length; j ++){
                                    if(arr[i] > arr[j]){
                                             int temp = arr[i];
                                            arr[i] = arr[j];
                                            arr[j] = temp;
                                       }
                               }
                      }
             }
              //输出数组的数据
             
              public static   void sysArr( int [] arr){
                 System. out.print("[" );
                       for(int i = 0 ; i < arr.length; i ++){
                          
                           if(i == arr.length - 1){
                              System. out.print(arr[i]+"]" );
                          } else{
                                   System. out.print(arr[i]+"," );
                               }
                 }
    }
    //冒泡排序
    public static void sort2(int[] arr){
              for(int i = 0; i < arr.length - 1; i ++ ){
                       for(int j = 0 ; j < arr.length - i - 1; j ++){
                                    if(arr[j] < arr[j + 1]){
                                         int    temp = arr[j];
                                            arr[j] = arr[j + 1];
                                            arr[j + 1] = temp;
                                       }
                          }
                 
                 }
         }
         
          //往一个有序的数组中插入数据，使数组还是有序状态二份查找要插入的位置
          public static int insertPostion(int[] arr, int key){
             
              int min = 0,max = arr.length - 1,mid = (min + max) / 2 ;
             
              while(min <= max){
                 
                  if(arr[mid] > key){
                          max = mid - 1;
                      } else if (arr[mid] < key){
                          min = mid + 1;
                      } else{
                                return mid;
                          }        
                          mid = (min + max) / 2 ;             
                 }
              return -1;
             }
}



----------------------------------------------------------------------------------------------------------------------------------
进制的转换：
     1.十进制转换为二进制：
          public void  toEr(int x) {
               StringBuffer sb = new StringBuffer();
               int sum = x % 2;
               sbappend(sum);
               sum >>1;
          }

     2. 十进制转换为十六进制：
          public void toShiLiu(int x){
                char [] chs = {'0','1','2','3','4','5','6','7','8','9','a','b','c','d'};  
               SringBuffer sb = new StringBuffer();
               for(int i = 0; i < 8; i ++){      
                    int sum = x & 15;
                   // if(sum > 9)
                  //       sum = (char)(sum - 10 +'a'); 
                  //  sb.append(sum);
                 //还可用查表法来找对应的十六进制数值：
                    sb.append(sum[i]);
                    x >>> 4;
                    sum.reverse();
               }     
          }

    3.通过抽取：
package xyxy.sjxy.day004;

public class ToArray{
    public static void main(String args[]){
          toArray(60,4);
    }
    //定义一个公共的转换进制的方式：
    public static void toArray(int sum, int b){
          char[] chs = {'0','1' ,'2' ,'3' ,'4' ,'5' ,'6' ,'7' ,'8' ,'9' ,'a' ,'b' ,'c' ,'d' ,'e' };
          char[] chars = new char[32/b];
          int position = chars.length ;
          while(sum != 0){
              int temp = sum & ((1<<b)-1);
             chars[--position] = chs[temp];
             sum = sum>>>b;
         }
          for(int i = position-1 ; i < chars.length; i++ ){
         System. out.println(chars[position]);
         }
    }
}



  二维数组：可以理解为数组中的数组。
     int arr[][] = new int[3][4];//3表示二维数组的长度，4表示二维数组中的一维数组的长度。
     
     内存分配图：
          
java004

面向对象
     1.理解面向对象：
          举例：对象——冰箱
               面向过程：打开冰箱，存储进冰箱，关闭冰箱  （执行者）  
               面向对象：冰箱 ：打开，冰箱：存储，冰箱：关闭 （指挥者）
          对人开门的理解：（名词提炼法）
               人｛
                    开门（门）｛
                         门.开（）；
                    ｝
               ｝


               门｛
                    开（）｛｝
               ｝
          
 开发：找对象使用，没有就建立对象
          找对象，建立对象，用对象 ，维护对象关系；     
          
类 ：对现实生活中的事物的描述（属性和行为）
对象：就是这类事物，实实在在存在的个体


//属性是对应是类中定义的变量，行为对应的类中的函数。
//其实定义类，就是在描述事物，就是在定义属性和行为。


class Car{
     //描述颜色
     String color = "红色"；
     //描述轮胎
     int sum = 4；
     //运行行为
     void run(){
          sysout....... 
     }
}


class CarDemo{


     public static void main(String args[]){
          //生产汽车，在java中通过new操作符来创建对象。
          //其实就是在堆内存产生一个实体
          Car c = new Car();//c为类类型变量，指向对象
          //
      }


}
         
局部变量与成员变量
     局部：在栈内存中存在，不会被默认的初始化 不能直接使用。
     成员：在堆内存中存在，会被默认初始化，可以直接使用。




1. 封装（encapsulation）
     是对隐藏对象的属性和实现细节，仅对外提供公共的访问方式。
          好处：
               1，将变化隔离
               2，便于使用
               3，提高了重用和安全性
          封装原则：
               1，将不需要对外提供的内容都隐藏起来
               2，把属性都隐藏起来，提供公共的方法访问




构造函数：
     特点：
          1.函数和类名相同
          2.不需要定义返回值类型
          3.不可写return语句
     作用：
          给对象初始化
     注意:
          1.多个构造函数是以重载的形式存在的。


构造代码块
     作用：给对象进行初始化，对象一建立就运行，而优先于构造函数


 构造函数 和 构造代码块的区别
     构造代码块是给所有对象进行统一的初始化
     而构造函数是给对应对象的初始化。
     构造代码块中定义的是不同对象共性的初始内容。
pulbic class Demo{


     {
          sys.out.print("initing......");
     }
     public Demo(){
          
     }
}


this关键字：
     1. 看上去，是用于区分局部变量和成员变量的区别（重名问题）
     2. 代表本类的对象，到底代表哪一个？
               this代表它所在函数所属对象的引用
               简单说：哪个对象在调用this所在函数，this就代表哪个对象
                              谁调用了这个函数，那么this就代表那个对象
      3. this的应用：
                           1. 定义类中的函数时，该函数内部要要用到调用该函数的对象时，
                              这时用this来表示这个对象。
                              但凡本类函数内部使用了本类对象都用this表示。
                           2.this语句：用于构造函数之间的进行互相调用（在一般函数中不能调用构造函数的，因为this语句只能在构造函数间调用）。
                                             this语句只能在构造函数的第一行，因为初始化要先执行。
----------------------------------应用1示例-----------------------------------------------------
public class Person{
     private int age;
     private String name;
     Person(String name,int age){
          this.name = name;
          this.age = age;
     }
     public boolean compare(Person p){
          return this.age == p.age;
     }
}
public class Demo{
     public static void main(String args[]){
          Person p = new Person("lisi",12);
          p.compare(new Peron("zhangsan",32));
     }
}
 -----------------------------------应用2示例--------------------------------  
   public clas Person{
        private String name;//成员变量，实例变量
          private static String where = "中国";//静态成员变量，类变量
        private int age;     
     public person(){
          }
     public Person(String name){
          this();//new Person();
          this.name = name;
     }
     public Person(String name,int age){
          this(name);//new Person(name);
          this.age =age;
     }
}  


Person p = new person("lisi",43);     


static关键字（共享成员）
     1. 随着类加载而加载，随着类的消失而消失（说明它的生命周期最长）
     2. 优先于对象的存在，明确一点：静态是先存在的，对象是后存在的
     3. 可以被所有对象所共享
     4. 是一个修饰符，用于修饰成员
     2. 当成员用static修饰时，它被访问多了新的方式：类.成员
     
实例变量 和 类变量的区别：
     1.存在位置。
               类变量随着类的加载而存在于方法区中。
               实例变量随着对象的建立而存在于堆内存中。
     2.生命周期
               类变量生命周期最长，随着类的消失而消失
               实例变量生命周期随着对象的消失而消失。
静态使用注意事项：
     1. 静态方法只能访问静态成员。
     2. 非静态方法既可以访问静态成员也可以访问非静态成员。
     3. 静态方法中不可以定义 this super关键字
               因为静态优先于对象而存在，所以静态方法中不可以出现this super
     4. 主函数都是静态的
静态的利与弊
     利：
          对对象的共享数据进行单独空间存储，节省空间，没有必要在每个对象中都存储一份
     弊： 
          生命周期过长
          访问出现局限（静态 访问 静态）


主函数：
     是一个特殊的函数，是程序的入口，可以被jvm调用
     public ： 代表着该函数访问权限是最大的
     static ： 代表主函数随着类的加载就已经存在了
     void ： 主函数没有具体的返回值
     mian ： 不是关键字，但是一个特殊的单词，可以被jvm识别
主函数是固定的格式的： jvm识别
java启动jvm在调用主函数时，默认传入的是new String[0]；
     class MainDemo{
          public static void main(String args[[]){}//只是识别这个 固定的
          public static void main(int[] args){}//重载，这个是可以存在的，没有问题
     }
javac 调用底层编译器，java调用底层的jvm        java  类  参数【】


什么时候使用静态？
     什么时候定义静态变量（类变量）呢？


          


静态的应用：
     代码共享


说明书的制作
     java说明书通过文档注释完成/****/


/**

@version V1.1

@author 作者

*/

public class ArrayTool {

     /**

     @param 接收一个数组

     @return 返回一个整型数据

     */

     public static int getMax(int[] arr){

          int max = 0;

          for(int i = 0; i < arr.length; i ++){

               if(arr[i] > arr[max])

                    max = i;

          }

          return arr[max];

     }

}



在doc中使用命令生成文档
     javadoc [options] [packgenames] [sourcefiles] [@files]
          eg: javadoc -d c:\myhelp -verson -author ArrayTool.java    
一个类中默认会有一个空参数的构造函数
     这个默认的构造函数的权限和所属类一致。 


静态代码块：
     格式：static｛
                    静态代码块中的执行语句
                    ｝
     特点：随着类的加载而执行，只执行一次并且优先于主函数（因为他也是要被调用的过程才执行）。
               用于给类进行初始化。
class  Demo2

{

     public static void main(String[] args)

     {

          new StaticDemo(4);

          System.out.println("Hello World!");

     }

}



class StaticDemo {

     public StaticDemo(){

          System.out.println("qqq");

     }

     public StaticDemo(int c){

          this();

          System.out.println(c);

     }

     static {//静态代码块

          System.out.println("aaa");

     }

     {//构造代码块

          System.out.println("vvv");

     }

}
输出的结果：aaa   vvv   qqq    4    hello world！


对象的初始化过程：
       Person p = new Person("zhangdan","30");
               这个语句都做了什么事情？
          1. 因为new用到了Person.class文件所以首先找到Person.class 文件并加载到内存中。
          2. 执行该类汇总的static代码块，如果有的话，给Person.class类进行初始化。
          3. 在堆内存中开辟空间，分配内存地址。
          4. 在堆内存中建立对象的特有的属性，并在进行默认的初始化。
          5. 对属性进行显示的初始化。
          6. 对对象进行构造代码块的初始化。
          7. 对对象进行对应的构造函数的初始化。
          8. 将内存地址赋给栈内存中的p对象。 


 对象调用成员的过程：
   
设计模式：饿汉式和懒汉式
     单例设计模式：解决一个类只能在内存中存在一个对象。
     建议使用饿汉式
         






























     