对java前6章的总结（标识符--关键字--数组--控制流程--面向对象）

今天对前面所学的内容进行一次大致的回顾：

标识符：

1. 1.标识符由字母、数字、下划线“_”、美元符号“$”组成，第一个字符不能是数字。
2. 2.不能把 java关键字和 保留字作为标识符。
3. 3.标识符没有长度限制。
4. 4.标识符对大小写敏感。

关键字：Java的关键字对Java的编译器有特殊的意义，他们用来表示一种数据类型，或者表示程序的结构等，关键字不能用作变量名、方法名、类名、包名和参数。

abstract	assert	boolean	break	byte
case	catch	char	class	const
continue	default	do	double	else
enum	extends	final	finally	float
for	goto	if	implements	import
instanceof	int	interface	long	native
new	package	private	protected	public
return	strictfp	short	static	super
switch	synchronized	this	throw	throws
transient	try	void	volatile	while

数组：

所谓数组，是相同数据类型的元素按一定顺序排列的集合。若将有限个类型相同的变量的集合命名，那么这个名称为数组名。组成数组的各个变量称为数组的分量，也称为数组的元素，有时也称为下标变量。用于区分数组的各个元素的数字编号称为下标。数组是在程序设计中，为了处理方便， 把具有相同类型的若干变量按有序的形式组织起来的一种形式。这些按序排列的同类数据元素的集合称为数组。 

java中数组的定义方法：【数据类型】 数组名[] = new 【数据类型】 [length];

注：数据类型可以是任意的数据类型，包括基本数据类型和引用数据类型

数组排序：

一般常用的排序：冒泡排序，选择排序，快速排序，二分排序，堆排序==

以下用两个例子分别介绍冒泡排序和选择排序：

冒泡：

for(int i=0;i<a.length-1;i++){

    for(int j=0;j<a.length-i-1;j++){

        int temp = a[j];

        if(a[j] > a[j+1]){

            a[j]=a[j+1];

            a[j+1]=temp;

        }

     }

}

java内置的冒泡排序：

Arrays.sort(a);

选择：

for(int i=0;i<a.length-1,i++){

     for(int j=i+1;j<a.length;j++){

       if(a[i]>a[j])

          int temp=a[i];

          a[i]=a[j];

          a[j]=temp;

      }

}

  控制流程：顺序流程，多分支流程

if语句：

if（boolean）{}else if()...

while语句：

while(boolean){

(break;)

};

do while语句：

do{

}while(boolean);

for循环语句：

for(;;){

}

面向对象：

概念：当我们遇到一个问题的时候，对问题进行分析，创造问题模型（类），用模型（类）创造对象，用对象解决问题的方式，特点：封装，继承，多态

封装：当我们使用私有的修饰符将属性的访问范围限制在类内的时候，我们将他称为封装，一般封装之后，我们会创建公共的setter和getter方法以达到赋值和获取值的功能。

例如：

private int num;

public void setNum(int num){

    this.num = num;

}

public int getNum(){

    return this.num;

}

继承：当几个类中有公有的属性和方法时，我们将这些公有的属性和方法抽取出来，成为一个父类。我们可以叫其他类继承父类。

例子：

class A{

int n;

public void num(){

}

}

class B extends A{

}

在B中我们可以访问从A继承的所有属性和方法

注：由于修饰符的访问范围不同；同包下，子类可以继承父类所有的非私有化的属性和方法；

不同包下，子类可以继承父类的公开的和受保护的属性和方法。

多态：

向上转型：子对象由子类型转为父类型；子类保留从父类继承的属性和方法，若方法被重写，依旧使用子类本身的方法

向下转型：子对象由父类型向下转为子类型

多态产生的条件：1.继承 2.向上转型 3.方法重写

例子：

class p{

public void speak(){

System.out.println("我喜欢吃东西");

 }

}

class c1 extends p{

public void speak(){

System.out.println("我喜欢吃西瓜");

 }

}

class c2 extends p{

public void speak(){

System.out.println("我喜欢吃香蕉");

 }

}

public class test{

public static void test1(p p1){

   p1.speak();

}

public static void main(String[] args){

    test1(new c1());

    test2(new c2());

}

}