嵌入式软件开发培训笔记——Java第二天（运算符、程序结构、数组与继承）

一、运算符

    分割符：，、；、[]、()

    算术运算符：+、-、*、/、%、++、--

    关系运算符：>、<、>=、<=、==、!=

    布尔逻辑运算符：!、&、|、^、&&、||

    位运算符：&、|、^、~、>>、<<、>>>

    赋值运算符：= 扩展赋值运算符：+=、-=、*=、/=

    字符串连接运算符：+

    造型操作符：() 

    其中位运算符^：

        一个数与另一个数按位异或得到的结果再次与这个数相异或，结果被还原。

        (A ^ B) ^ B == A

        1). A计划--->加密

        2). 不通过第三方变量进行两个数的交换

    其中无符号右移位运算符<<<：

    其中作为字符串连接符的“+”：把字符串连接起来生成一个新的字符串对象返回。

    字符串类型与其他任何类型的变量相“加”，其他的数据类型都会被自动转换成字符串类型。

     其中三目条件运算符x?y:z中x必须为布尔类型。

    其中移位运算符中：如(13 >> 35)等价于(13 >> 3)

    如何将一个数字转换成字符串？用“+”符号

    

二、程序结构

1、分支语句

    注意:if语句中括号内必须是一个布尔类型

            switch语句，表达式中的类型为byte/short/int/char    另String(在JDK1.7及以上版本合适)

            例：利用switch实现从健盘中输入星期几的字符串，按照输入的字符串输出相应的语句。

                键盘输入即C语言中scanf函数在JAVA中的实现是：

                    Scanner sc = new Scanner(System.in);

                    String province = sc.next();

2、循环语句

    for

    while

    do/while

    break/continue

        break可用于for/while/do-while/switch语句中，用于循环语句中，跳出一层循环。

        可以使用加标签的方式，直接从内层循环跳出外层循环，相当C语言中的goto语句。

        注意：所加的标签与C语言中不一样的地方，只能加在循环体的开头部分。

        continue语句，结束当前的循环，进入下次的循环，它也能用加标签的方法。

三、数组

    数组是用来存储一组相同数据类型数据的数据结构

    数组的元素可以是简单类型的数据，也可以是引用类型的数据

    

   掌握数组的声明

    掌握数组的初始化

   掌握数组的拷贝和排序

    一维数组用法四步走：

    1、声明

            int[] a;

    2、分配空间

            a = new int[5];

    3、赋值

            a[0] = 8;

    4、数据处理

            a[0] = a[0] * 10;

    

    任何数组对象都有一个length属性，直接返回数组长度。

    在java中数组是严格检查边界的。

     Array.sort()方法  调用后会自动进行排序

    public class ArraysSort{

        public static void main(String args[]){

            int[] a = {10, 3, 19, 2, 11, 15};

            System.out.println("排序前:");

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

                    System.out.print(a[i]+"");

             Arrays.sort(a);

            System.out.println("排序后:");

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

                     System.out.print(a[i]+"");

        }

    }

    数组值的拷贝

     System类的静态方法System.arraycopy()

    参数：

            ---src-->源数组

             ---srcPos-->源数组中的起始位置

            ---dest-->目标数组

            ---destPos-->目标数组中的起始位置

            ---length-->要复制的数组元素的数量

    作用：从指定源数组中复制一个数组，复制从指定的位置开始，到目标数组的指定位置结束。

    多维数组的声明：

        int[][] intArray;

        double dbArray[][];

        int[][][] intArray;

        String strArray[][][];

        需要注意的是：

        （1）多维数组中当使用new来创建时，不必指定每一维的大小，但要指定最左边的维的大小。

        如：int[][] array = new int[2][];

        （2）二维数组： int[][] array = {{1,2,3},{4,5,6},{7,8,9},{10,11,12}};    array.length = 4(即行数)，array[i].length = 3(指的是某一行的长度)

        （3）二维数组的声明和初始化应按从高维到低维的顺序进行，例如：

                   int a[][] = new int[3][];

                    a[0] = new int[2];

                    a[1] = new int[4];

                    a[2] = new int[3];

    

    public static void main(String[] args)中自带参数用法

         public class test {

            public static void main(String[] args){

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

                        System.out.println(args[i]);

            }

        }

    参数设置方法：右击java源文件名选择run as，再选择run configrations，在打开的窗口中选择(x)=Arguments选项，然后在Program arguments文本框中输入参数，参数之间用空格或回车分开。

    数组实现堆栈的算法

stack类

测试程序

package stack; public class stack {  int[] mystack;  int top;  int maxsize;    /*create empty stack*/  public stack(int max){   this.maxsize = max;   mystack = new int[max];   top = -1;  }    /*get stack size*/  public int get_size(){   return maxsize;  }    /*return element count*/  public int get_count(){   return top;  }    /*clear stack*/  public void clear_stack(){   top = -1;   for(int i = 0; i < mystack.length; i++){    mystack[i] = 0;   }  }    /*if stack full*/  public int full_stack(){   if(top == (maxsize-1)){    return 1;   }else{    return 0;   }  }    /*if stack empty*/  public int empty_stack(){   if(top == -1){    return 1;   }else{    return 0;   }  }    /*pop stack*/  public int pop_stack(){   return mystack[top--];  }    /*push stack*/  public void push_stack(int arg){   mystack[++top] = arg;  }    /*get top*/  public int get_top(){   return mystack[top];  } }

package stack; public class test {  public static void main(String[] args){   stack an = new stack(5);       if(an.full_stack() == 0){    an.push_stack(10);   }     if(an.full_stack() == 0){    an.push_stack(9);   }     if(an.full_stack() == 0){    an.push_stack(8);   }     if(an.full_stack() == 0){    an.push_stack(7);   }     if(an.full_stack() == 0){    an.push_stack(6);   }     if(an.full_stack() == 0){    an.push_stack(5);   }   while(an.get_count() > 0){    if(an.empty_stack() == 0){     System.out.println(an.pop_stack());    }   }     System.out.println(an.get_top());  } }

四、继承

extends

子类继承父类所有的属性和方法。构造器除外。

特点：面向对象的重要特征

          可以实现代码的复用

java只支持单继承，跟C++不一样。

即一个类父类只能有一个，子类可以有多个。

基本语法：

            访问控制                    子类名                            父类

            <modifier>    class    <name>    [extends<superclass>]

            {

                        <declaration>*

            }

在类、类的属性以及类的方法前面加修饰符可限定其访问权限，实现其在一定范围内的信息隐藏。

修饰符	同一个类中	同一个包中	子类中	全局
private	yes
default	yes	yes
protected	yes	yes	yes
public	yes	yes	yes	yes

父类	子类（并继承父类所有的东西）	测试程序
public class Animal {  String name;  int age;  float weight;    public Animal(){   super();  }    public Animal(String name, int age, float weight){   this.name = name;   this.age = age;   this.weight = weight;  }    public String getName(){   return name;  }    public void setName(String name){   this.name = name;  }    public int getAge(){   return age;  }    public void setAge(int age){   this.age = age;  }    public void setWeight(int weight)     {   this.weight = weight;     }  public float getWeight()  {   return weight;  }    public void eat(){   System.out.println("动物在吃...");  }    public void roar(){   System.out.println("动物在吼叫...");  } }	public class dog extends Animal {  public void watchHome(){   System.out.println(getName()+"在看门");  } } /*新建子类时使用extends关键字，若使用eclipse创建子类时在新建向导框中的Superclass选项处填上父类名*/	public class Test {  public static void main(String[] args){   dog xiaobai = new dog();   xiaobai.setName("小白");   xiaobai.eat();   xiaobai.roar();     xiaobai.watchHome();     System.out.println(xiaobai.getAge());  } }

方法覆盖（override）

     子类重写父类的同名方法和父类成员变量同名的成员变量

    1、方法名必须相同

    2、参数列表必须相同

    3、返回值类型必须相同

    4、子类的权限只能更开放

    5、抛出的异常只能列少

    @Override

    

super关键字

    super代表着父类对象的一个引用。 

    super关键字的用法

访问父类的成员变量—— super.变量

访问父类中被重写的方法——super.方法([参数列表])

访问父类的构造器——supe([参数列表])

    

    将“方法覆盖（override）”下截图中super.eat()及super.roar()前注释去掉，即访问父类中被重写的方法。

    父类与子类中同名的变量并不是在同一存储空间的。

关于构造器的super

    创建子类对象时，要先创建父类对象。子类对象包含着父类对象。

    当子类构造器没有使用super显示地调用父类构造器时，系统会默认地调用父类的无参构造器。