首页 > 代码库 > Java学习-第二天
Java学习-第二天
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 PersonDemoHi,i am from the Worldmy name isnull, I‘m 0.Hi,i am from CNmy 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 PersonDemoHi,i am from CHINAmy name isnull, I‘m 0.Hi,i am from CNmy 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学习-第二天