码迷,mamicode.com
首页 > 编程语言 > 详细

Java学习-第二天

时间:2014-10-12 14:02:17      阅读:165      评论:0      收藏:0      [点我收藏+]

标签:des   blog   io   使用   ar   java   for   数据   sp   

03day 

   

  1.循环结构

  1).while语句  

while(条件表达式)
{
    执行语句;
}
//while语句判断条件符合则运行,直到判断条件不成立或遇到break 跳出循环

  2).do while 语句

do
{
    执行语句;
} while(条件表达式)
//do while 语句无条件运行一次后才开始判断条件是否满足。条件不满足则跳出循环

  3).for 语句

for(初始化表达式;循环条件表达式;循环后操作表达式)
{
    执行语句;
}
// for和while可以进行互换。如果需要定义循环增量,用for更为适合。

//无线循环表现形式

for(;;)
{

}

 while(1)
{

}

  4).for循环练习

class  D3PrintXing  //打印形状星型
{
    public static void main(String[] args) 
    {
        for(int i=6; i>0;i--){

            for(int j=i; j>0;j--){
                System.out.print("*");
            }
            System.out.println("");
        }    
    }
}

class D3ChengFaBiao  // 打印乘法表
{
    public static void main(String[] args) 
    {
        for(int i=1; i<10;i++){

            for(int j=i; j>0;j--){
                System.out.print(i + "*" + j + "=");
                if(i*j<10){
                    System.out.print("0"+i*j);
                }
                else{
                    System.out.print(i*j);
                }
                System.out.print(" ");
            }
            System.out.println("");
        }
    }
}

   2.break和continue

  break此语句导致程序终止包含它的循环,并进行程序的下一阶段(整个循环后面的语句),即,不是跳到下一个循环周期而是退出循环。如果break语句包含在嵌套循环里,它只跳出最里面的循环。

  

  continue:程序运行到此语句时,不在执行循环体里continue后面的语句而是跳到下一个循环入口处执行下一个循环。如果continue语句包含在嵌套循环语句里,它只影响包含它的最里层的循环。

  

  3.函数

  函数就是定义在类中的具有特定功能的一段独立对的小程序。

  

函数的格式:
修饰符 返回类值类型 函数名(参数类型 形式参数1)
{
执行语句;
return 返回值;
}
返回值类型:就是函数运行后的结果的数据类型。
参数类型:就是形式参数的数据类型。
形式参数:就是一个变量,这个变量时用于存储调用函数时给函数传递实际参数用的。
实际参数:就是传递形式参数的具体数值。
return:用于结束函数。
返回值:该值会返回给调用者。

main函数就是一个典型的函数

static void main(String[] args)
{
    System.out.println("Hello World");
    return;
}

函数的重载 overload

在同一个类中,允许存在一个以上的同名函数,只要他们的参数个数或参数类型不同即可存在函数重载关系。

重载的特点:
函数重载与返回值类型无关,与参数列表有关。

4.数组
数组就是同一种数据类型的集合。
定义数组
元素类型[] 数组名 = new 元素类型[元素个数或数组长度];

int [] arr = new int[5];

元素类型 [] 数组名 = new 元素类型[]{元素1,元素2,...,元素n };

int [] arr = new int[] {21,31,43,52,12,312,431};

内存结构

Java程序正在运行时,需要在内存中分配空间。为了提高运算效率Java对内存空间进行了不同区域的划分,因为每一片区域都有特定的处理数据方式和内存管理方式。

栈内存
用于存储局部变量,当数据使用完毕,该变量所占用的空间会自动释放。

堆内存
数组和对象,通过new的方式建立的实例都存放在堆内存中。每一个实例都有内存地址值,实例中的变量都有默认的初始化值,实例不再被使用,占用的空间不会立刻自动释放,而是在不确定的时间被Java垃圾回收器回收。

方法区

本地方法区

寄存器

 

04day

 

class D4ArraySort //选择排序
{
    public static void main(String[] args) 
    {
        int[] array = new int[] {43,656,754,887,112,2,41,512,1131,213,232,323,32,22,3,212,361};

        //排序前
        printArray(array);

        SelectSort(array,true);

        //排序后
        printArray(array);

        array = new int[] {43,656,754,887,112,2,41,512,1131,213,232,323,32,22,3,212,361};
        //排序前
        printArray(array);

        BubbleSort(array,true);

        //排序后
        printArray(array);
    }

    //选择排序
    /*
    每一趟从待排序的数据元素中选出最小(或最大)的一个元素,顺序放在已排好序的数列的最后,直到全部待排序的数据元素排完。
    */
    //Desc 排序是否从大到小,
    public static int[] SelectSort(int[] arr,Boolean Desc)
    {
        System.out.println("*******************  SelectSort  *********************");
            
        if(arr == null)
        {
            return arr;
        }

        if(Desc)
        {
            for (int i=0;i<arr.length-1;i++ )
            {
                for (int j=i+1;j<arr.length ;j++ )
                {
                    if(arr[i]<arr[j])
                    {
                        swap(arr,i,j);
                    }
                }
                System.out.print("i‘="+i+" ");
                printArray(arr);
            }
        }
        else
        {
            for (int i=0;i<arr.length-1;i++ )
            {
                for (int j=i+1;j<arr.length ;j++ )
                {
                    if(arr[i]>arr[j])
                    {
                        swap(arr,i,j);
                    }
                }
            }
        }

        return arr;
    }

    //冒泡排序
    /*
    冒泡排序算法的运作如下:(从后往前)
    比较相邻的元素。如果第一个比第二个大,就交换他们两个。
    对每一对相邻元素作同样的工作,从开始第一对到结尾的最后一对。在这一点,最后的元素应该会是最大的数。
    针对所有的元素重复以上的步骤,除了最后一个。
    持续每次对越来越少的元素重复上面的步骤,直到没有任何一对数字需要比较。
    */
    public static int[] BubbleSort(int[] arr,Boolean Desc)
    {
        System.out.println("*******************  BubbleSort  *********************");
            
        if(arr == null)
        {
            return arr;
        }

        if(Desc)
        {
            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])
                    {
                        swap(arr,j,j+1);
                        
                    }
                }
                System.out.print("i‘="+i+" ");
                printArray(arr);
            }
        }
        else
        {
            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])
                    {
                        swap(arr,j,j+1);
                    }
                }
            }
        }

        return arr;
    }

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

    //交换位置
    public static void swap(int [] arr ,int x, int y)
    {
        int temp = arr[x];
        arr[x] = arr[y];
        arr[y] = temp;
    }
}


class D4GetArrayIndex
{

    public static void main(String[] args)
    {
        int [] arr =new int[] { 1,3,4,6,8,12,15,16,35,67,69,70,92};
    
        int index = -1;

        index = halfSearch2(arr,16);
        System.out.println("index= "+index);
    
    }

    //二分查找
    public static int halfSearch(int[] arr,int key)
    {
        int min,mid,max;

        min = 0;
        max = arr.length-1;
        mid = (min+max)/2;

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

            if(min>max)
                return -1;

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

    //二分查找
    public static int halfSearch2(int[] arr, int key)
    {
        int min = 0, max = arr.length-1, mid = 0;

        while(min <= max)
        {
            mid = (min+max) >> 1;

            if(arr[mid]<key)
                min = mid + 1;
            else if(arr[mid]>key)
                max = mid - 1;
            else
                return mid;
        }        
        return -1;
    }    

}

 

  05day

 

1.面向对象
面向对象是一种对现实世界理解和抽象的方法。通过面向对象的方式,将现实世界的事物抽象成对象,现实世界中的关系抽象成类、继承,帮助人们实现对现实世界的抽象与数字建模。

2.现实世界与抽象世界
定义一个类就是在描述现实世界的事物过程中定义类的属性和行为。
1)类就是对现实世界中事物的描述。
2)对象就是这类事物,确确实实的存在个体
3)属性对应类中的就是变量
4)行为对应到类中就是函数

3.成员变量和局部变量的联系与区别
1)作用范围:
成员变量作用于整个类中。
局部变量作用于函数中,或者语句中。
2)在内存的位置:
成员变量:在堆内存中,因为对象的存在,才在内存中存在。
局部变量:存在于栈内存中。

4.匿名对象
匿名对象就是对象的简化形式。
匿名对象两种使用情况:
1).当对对象方法仅进行一次调用时
2).匿名对象可以作为实际参数进行传递

5.封装
封装就是指隐藏对象的属性和实现的细节,仅对外提供公共访问方式。
封装的原则:
将不需要对外提供的内容都隐藏起来。
把属性都隐藏,提供公共方法对其访问。
封装的好处:
将变化隔离,便于使用,提高重用性,提高安全性。

 

class  Person
{
    private int age; //private :私有,权限修饰符,用于修饰类中成员。 私有只在本类中有效。
    //这里将age属性私有化就是为了封装age,只能通过setAge()方法修改本类中的age属性。
    
    void setAge(int age)
    {
        if(age>0 && age<150)
        {
            this.age = age;
        }
    }

    void speak()
    {
        System.out.println("age="+age);
    }    
}

class PersonDemo
{
        public static void main(String[] args) 
    {
        Person p = new Person();
        
        p.setAge(20);
        //p.setAge(-10) //年龄错误,
        p.speak();
    }
}

  

6.构造函数


构造函数,是一种特殊的方法。主要用来在创建对象时初始化对象,即为对象成员变量赋初始值,总与new运算符一起使用在创建对象的语句中。
构造函数的特点:
1.函数名与类名相同。
2.不用定义返回会类型也没有return。
3.当类中没有定义构造函数,系统会默认给该类加入一个空参数的构造函数。

class  Person
{
    private int age; 
    private String name;

    //Person(){} 默认构造函数
    
    Person()
    {
        speak();
    }

    Person(String name,int age)
    {
        this.name = name;
        setAge(age);

        speak();
    }


    void setAge(int age)
    {
        if(age>0 && age<150)
        {
            this.age = age;
        }
    }

    void speak()
    {
        System.out.println("name = "+name+", age = "+age);
    }
    
}

class PersonDemo
{
        public static void main(String[] args) 
    {
        Person p = new Person();
        
        Person p1 = new Person("哈",30);

    }
}
/*
构造函数与一般函数的区别
在运行上,构造函数时在对象一建立就立即运行,用来给对象进行初始化
而一般方法是在对象调用才执行,是给对象添加对象具备的功能。

一个对象建立,构造函数只运行一次。
而一般方法可以被该对象调用任意次运行。

*/

 

7.构造代码块
作用:给对象进行初始化,
对象一建立就运行,而且优先于构造函数执行。构造代码块中定义的是不同对象共性的初始化内容。
与构造函数的区别:
构造代码块是给所有对象进行统一初始化,而构造函数是给对应的对象进行初始化。

class  Person
{
    private int age; 
    private String name;

    //Person(){} 默认构造函数
    


    Person()
    {
        speak();
    }

    Person(String name,int age)
    {
        this.name = name;
        setAge(age);

        speak();
    }


    void setAge(int age)
    {
        if(age>0 && age<150)
        {
            this.age = age;
        }
    }

    void speak()
    {
        System.out.println("name = "+name+", age = "+age);
    }

    {
        System.out.println("这个构造代码块,所有的对像建立都运行一次,而且优先于构造函数运行!");
    }
    
}

class PersonDemo
{
        public static void main(String[] args) 
    {
        Person p = new Person();
        
        Person p1 = new Person("哈",30);

    }
}

 

 

8.this 关键字
this主要是为了强调对象本身来说的.通俗一点说,就是this表示当前这个对象。

this的另外一个用法:用this调用构造函数

  

class Person
{
    private String name ;

    private int age ;

    public Person()
    {
        System.out.println("1. public Person()");
    }

    public Person(String name,int age)    
    {
        this() ;// 调用本类中无参构造方法

        this.name = name ; //this表示当前这个对象

        this.age = age ; //this表示当前这个对象

        System.out.println("2. public Person(String name,int age)");
    }
}

 

9.static 关键字
用法:是一个修饰符。用于修饰成员(成员变量和成员函数).
当成员变量被静态修饰后,就多了一个调用方式,除了可以被对象调用外,还可以直接被类名调用。(类名.静态成员)

static的特点:
1.随着类的加载而加载,随着类的消失而消失,声明周期最长。
2.优先于对象存在
3.被所有对象共享
4.可以直接被类名调用

实例变量和类变量的区别
1.存放位置
类变量随着类的加载而存在于方法区中
实例变量随着对象的建立而存在于堆内存中
2.生命周期
类变量生命周期最长。
实例变量随着对象的消失而消失

静态使用的注意事项
1.静态方法只能访问静态成员
非惊天方法可以访问非静态和静态
2.静态方法中不可以使用this、super等关键字
因为静态优先于对象存在,所以静态方法中不可以出现this关键字

静态有利弊
利:对对象的共享数据进行单独空间的存储,节省空间。没有必要对个对象都存在一份。可以被类名直接调用
弊端:生命周期过长,访问出现局限性。

class  Person
{
    private int age; 
    private String name;
    private static String country = "the World";

    //Person(){} 默认构造函数   

    Person()
    {
        speak();
    }

    Person(String name,int age)
    {
        this.name = name;
        setAge(age);

        speak();
    }

    void setAge(int age)
    {
        if(age>0 && age<150)
        {
            this.age = age;
        }
    }

    void speak()
    {
        System.out.println("my name is"+name+", I‘m "+age+".");         
    }

    {        
        this.country = "CN";         
    }

    static void sayHello()
    {
        System.out.println("Hi,i am from "+country);
        //System.out.println("my name is "+name+", I‘m "+age+"."); //错误静态方法不能调用非静态成员            
    }    
}

class PersonDemo
{
        public static void main(String[] args) 
    {
        Person.sayHello(); //类名.静态方法(),因为静态代码块运行优先于代码块,所以国籍还是世界。
        
        Person p = new Person();
        p.sayHello();
        
        Person p1 = new Person("Li",30);

    }
}
/*

运行结果
F:\JAVA\code>java PersonDemo
Hi,i am from the World
my name isnull, I‘m 0.
Hi,i am from CN
my name isLi, I‘m 30.

什么时候使用静态变量?
当对象中出现共享数据时,该数据使用静态修饰。
什么时候使用静态函数
当功能内部没有访问非静态数据,那么该功能可以定义为静态。

*/

 

10 主函数
public static void main(String[] args)
主函数:是一个特殊的函数,是作为程序的入口,可以被JVM调用。

主函数的意义:
public :代表着该函数的访问权的最大的。
static :代表着主函数随着类的加载就已经存在了。
void :代表着主函数没有返回值。
main: 不是关键字,但是是一个特殊的单词可以给JVM识别
(String[] args): 主函数的参数,参数是一个字符串数组。

jvm在调用主函数是,传入的是 new String[0];

 

11.私有化的构造函数可以防止类被实例化

public class A
{
private A(){};

}

class ADemo
{
A a = new A(); //编译失败
}

   12.生成说明文档的格式(公共类才能用)

  javadoc -d 生成目录 -author -version 类名.java

   eg. javadoc -d c:\-author -version D1.java

  

13.静态代码块
格式:
static
{
//静态代码块中的执行预计
}
特点:随着类的加载而执行,且只执行一次,用于给类初始化。方法内不能调用非静态成员。

class  Person
{
    private int age; 
    private String name;
    private static String country = "the World";
    

    //Person(){} 默认构造函数

    //private Person(){} //私有化构造函数可以防止建立该类的对象

    Person()
    {
        speak();
    }

    Person(String name,int age)
    {
        this.name = name;
        setAge(age);

        speak();
    }


    void setAge(int age)
    {
        if(age>0 && age<150)
        {
            this.age = age;
        }
    }

    void speak()
    {
        System.out.println("my name is"+name+", I‘m "+age+"."); 
    }

    static void sayHello()
    {
        System.out.println("Hi,i am from "+country);
        //speak(); //错误静态方法不能调用非静态成员            
    }

    {
        this.country = "CN";            
    }

    static
    {
        country = "CHINA";        //静态代码块优先于代码块执行    
        //speak(); /错误代码块不能调用非静态成员
    }
    
}

class PersonDemo
{
        public static void main(String[] args) 
    {
        Person.sayHello(); //类名.静态方法(),因为优先于代码块,所以国籍是"CHINA"。
        
        Person p = new Person();
        p.sayHello();
        
        Person p1 = new Person("Li",30);

    }
}
/*
运行结果
F:\JAVA\code>java PersonDemo
Hi,i am from CHINA
my name isnull, I‘m 0.
Hi,i am from CN
my name isLi, I‘m 30.
*/

14.单例模式

步骤:
1.将构造函数私有化
2.在类中创建一个本类对象
3.提供一个方法可以获取到该对象

/*饿汉试 建议使用 */
class D6Single
{
    private D6Single() {};
    
    private static D6Single s = new D6Single();

    public static D6Single getInstance()
    {
       return s;
    }

    private int num =0;

    public int getNum()
    {
        return num;
    }
    
    public void setNum(int num)
    {
        this.num = num;    
    }
}

class D6SingleDemo
{

    public static void main(String[] args) 
    {
        D6Single s =  D6Single.getInstance();
        s.setNum(2000);
    
        D6Single s1 = D6Single.getInstance();    
        System.out.println(s1.getNum());
    }

}

/*懒汉试 低效 */
class D6Single2
{
    private static D6Single2 single2 = null;

    private D6Single2(){ };
    
    //同步
    public static  D6Single2 getInstance2()
    {
        if (single2 == null)
        {   //双重判断
            synchronized(D6Single2.class)
            {
                if (single2 == null)
                    single2 = new D6Single2();
            }
        }
        return  single2;
    }

    private int num =0;

    public int getNum()
    {
        return num;
    }
    
    public void setNum(int num)
    {
        this.num = num;    
    }
}

class D6SingleDemo2
{
    public static void main(String[] args) 
    {
        D6Single2 s1 =  D6Single2.getInstance2();
        s1.setNum(2000);
    
        D6Single2 s2 = D6Single2.getInstance2();    
        System.out.println(s2.getNum());
    }
}

 

Java学习-第二天

标签:des   blog   io   使用   ar   java   for   数据   sp   

原文地址:http://www.cnblogs.com/lhy_2011/p/4020221.html

(0)
(0)
   
举报
评论 一句话评论(0
登录后才能评论!
© 2014 mamicode.com 版权所有  联系我们:gaon5@hotmail.com
迷上了代码!