javase基础

)

1、初识java

1.1java简介

java简介

1.2jdk下载和安装

jdk下载和安装

1.3Eclipse和IDEA

Eclipse和IDEA

1.4标识符

标识符

2.基础知识

2.1编写hello，word

package cn.atguoke.demo01;

public class Hello {
    public static void main(String[] args) {
        String src = "hello,word";
        System.out.println(src);
    }
}

注意的点：

• package cn.atguoke.demo01; 包名 有自己的域名后，把域名倒写就是包名
• public class Hello {} 类，也是对象java中所有的东西都是基于类来实现的 使用 class关键字来声明 语法：class 类名
• public static void main(String[] args) {} main方法 程序的主入口，程序会根据main方法重上到下依次执行。
• String src = "hello,word"; 声明变量 语法：数据类型 变量名;
• System.out.println(src); 输出语句 这个会在控制台输出定义的变量src；

2.2基本数据类型

• 数值型
  1. 整数类型(byte、short、int、long)
  2. 浮点型(float、double)
• 字符型
  1. char型:只能存放一个字符
  2. String型：可以存放多个字符 是个char型的数组
• 布尔型
  • boolean只有两个值true、false

详情请参考

2.3变量于常量

值可以改变的量称为变量、不可以改变的为常量。

2.3.1声明

• 变量：

语法： 数据类型 变量名=值;

• 常量：

语法：final 数据类型 常量名=值;  //使用final关键字来声明

2.4运算符及优先级

2.4.1运算符及优先级

2.4.1自增自减运算

package cn.atguoke.demo01;

public class Hello01 {
    public static void main(String[] args) {
        int a=5;
        System.out.println(a++);
        System.out.println(++a);
        System.out.println(a--);
        System.out.println(--a);
    }
}

++a与a++的区别：

• a++表示在使用a之后把a的值加一
• ++a表示使用a之前，就把a的值加一

2.5数据类型的转换

• 隐式类型的转换

  程序自动转化比如把int类型的值赋给了float，它会把值自动转换为float

• 显示类型的转换（强制类型转换）

语法：（类型名）要转换的值

详情参见

注意点：溢出问题

2.6注释

• 单行注释//
• 多行注释/**/

3、流程控制

3.1复合语句

以{}来标记，以块为单位的语句称为复合语句，又称为块语句。

 	{
        
    }

创建一个复合语句相当于创建了以一个作用域，在同级作用域下变量不能相通

3.2条件语句

3.2.1if语句

语法：

if（条件表达式）{
	语句1 //在条件成立时执行
}else if（条件表达式）{
	语句2  //在条件成立时执行
}else{
	语句3  //在条件没成立时执行
}

package cn.atguoke.demo01;

public class Hello02 {
    public static void main(String[] args) {
        int a= 1;
        if(a==2){
            System.out.println("1:hello,word");
        }else if(a==1){
            System.out.println("2:hello,word");
        }else {
            System.out.println("3:hello,word");
        }
    }
}

3.2.2switch多分枝语句

用于多值的判断

语法：

        switch (表达式){
            case 值1:
                语句块  1；
                [break;]
            case 值2:
                语句块  2；
                [break;]
            case 值3:
                语句块  3；
                [break;]
            default:
                语句块  4；
                [break;]
        }

如果不使用break的话在条件成立的后的语句都会执行

package cn.atguoke.demo01;

public class Hello3 {
    public static void main(String[] args) {
        int a=2;
        switch (a){
            case 1:
                System.out.println("星期一");
                break;
            case 2:
                System.out.println("星期二");
                break;
            case 3:
                System.out.println("星期三");
                break;
            default:
                System.out.println("Hello,word");
                break;
        }

    }
}

3.3循环语句

3.3.1while循环

语法：

while(条件表达式){
	执行语句
}

package cn.atguoke.demo01;

public class Hello04 {
    public static void main(String[] args) {
        int a =0;
        while (a<=10){
            System.out.println(a);
            a++;
        }
    }
}

3.3.2for循环

语法：

for（表达式1；表达式2；表达式3）{
	执行语句；	
}

        for (int i = 0; i < 10; i++) {
            System.out.println(i);
        }

3.3.3foreach

语法：

for（元素变量x：遍历对象）{
	执行语句；
}

        int[] arr= {1,2,3,4};

        for (int i : arr) {
            System.out.println(i);
        }

3.4循环控制

3.3.1break语句

作用：跳出当前循环

3.3.2continue语句

作用：跳过本次循环

详情参见

4.数组

1. 一维数组
2. 多维数组

4.1创建

方式：

• 数组元素类型 数组名[];
• 数组元素类型[] 数组名；

初始话值：

• int arr = new int[]{ 1,2,3};
• int arr[] ={1,2,3};

详情参见

4.2冒泡排序

在这里有两种算法：冒泡排序、二分法查找

package cn.atguoke.demo01;



public class Test_maopao {
	public static void main(String[]args) {
		int[]。
		= {2,5,35,45,45,45,78,54,45}; 
		Test_maopao a=new Test_maopao();
		a.show(arr);
		
	}
	
public void sort(int[] arr) {
	for(int j=0;j<arr.length;j++) {
		//比较两个数的大小
		for(int i=0 ;i<arr.length-j;i++) {
			if(arr[i]>arr[i+1]) {
				int temp=arr[i]; //把第一个元素保存到一个变量中
				arr[j]=arr[j+1];
				arr[j+1]=temp;
				
			}
		}
	}
	
}
public void show(int[]arr) {
	for (int i:arr) {
		System.out.println(i);
	}
}
}

package cn.atguoke.demo01;
/*
 * 测试二分法
 */


public class Test_erfenfa {
	public static int search(int[] array, int find){
		if(array == null){
			return -1;
		}
		int start = 0;
		int end = array.length - 1;
		int middle = 0;
		while(start <= end){
			middle = (start + end) / 2;//中间的位置
			if(array[middle] == find){//中间值等于要查找的值，直接返回
				return middle + 1;
			}else if(array[middle] < find){//中间值小于要查找的值，就在中间值后面继续查找
				start = middle + 1;
			}else{//中间值大于要查找的值，就在中间值前面继续查找
				end = middle -1;
			}
		}
		return -1;//未查找到，返回-1
	}


}

5.包装类

5.1包装类

详情参见

5.2Sprint包装类

详情参见

详情参见

6.面向对象

6.1概述

详细参见

6.2继承

使用extends 关键字 子类继承父类就拥有父类的方法及属性，继承是单继承；

详情参见

6.3组合【重点】

于继承向对应的含有一个组合

我们知道子类继承父类，子类可以取到父类的所有东西，但我们有没有一种方法来代替继承，同样可以使用父类的方法。答案是有的，这就是我们的组合。在javaweb开发中service层常常会调用dao层的值，使用继承的话会代码的耦合性会提高。

package cn.atguoke.demo01.组合;

public class Zoo {
    private String name;
    private int age;

    public Zoo() {
    }

    public Zoo(String name, int age) {
        this.name = name;
        this.age = age;
    }

    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;
    }

    @Override
    public String toString() {
        return "Zoo{" +
                "name='" + name + '\'' +
                ", age=" + age +
                '}';
    }
}

package cn.atguoke.demo01.组合;

public class Dog  {
    private Zoo zoo;

    public void setZoo(Zoo zoo) {
        this.zoo = zoo;
    }

}

这样就是组合

6.4方法的重写

方法的重写是基于继承的，当子类于父类的方法名参数相同的时候子类就会重写父类的方法，在用子类调用该的方法的时候，会执行子类的方法

6.5方法的重载

在一个类中方法的名称相同参数类型不同或者参数个数不同，在调用他们的时候可以通过传递不同的参数来实现不同的功能。

重载与重写

6.6this与super

详情参见

6.7抽象类

详情参见

6.8接口【重点】

接口可以理解称为一种规则，这中规则使我们的代码更加的规范，

详情参见

6.9多态【重点】

父类引用指向子类对象

详情参见