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());
}
}
posted on
