一、运算符
分割符：，、；、[]、()
算术运算符：+、-、*、/、%、++、--
关系运算符：>、<、>=、<=、==、!=
布尔逻辑运算符：!、&、|、^、&&、||
位运算符：&、|、^、~、>>、<<、>>>
赋值运算符：= 扩展赋值运算符：+=、-=、*=、/=
字符串连接运算符：+
造型操作符：()
其中位运算符^：
一个数与另一个数按位异或得到的结果再次与这个数相异或，结果被还原。
(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 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显示地调用父类构造器时，系统会默认地调用父类的无参构造器。
扫一扫
3540
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
