Java初级入门

Java初级入门



JAVA:高级语言：
1、强类型语言：
2、是完全面向对象的语言：C语言面向过程的语言   c++半面向对象的语言
3、既是编译型语言，也是解释型语言：
首先编写java源程序----> javac命令编译源程序（.class文件（2进制代码，字节码））---->java命令执行得到效果


编译：把高级语言写得源程序，整体用一个工具全部转化成为机器语言的目标程序。
java里面：编译的工具是javac，编译后形成的目标文件是一个以.class为扩展名的2进制码文件，又叫字节码文件。
解释：把高级语言编写的源程序或者是高级语言经过编译后形成的目标程序，解释一句就执行语句，不形成目标程序，就叫解释。
java里面：解释执行工具是java命令。


JAVA语言的特点：
1）面向对象
2）可移植性
3）安全性
4）并发机制
5）支持可视化图形界面



环境变量的设置：
1、创建JAVA_HOME:参数值：我们的jdk的安装路径
2、创建CLASSPATH：参数值：.;%JAVA_HOME%\lib.jar;%JAVA_HOME%\lib\tools.jar;
3、在path里添加：%JAVA_HOME%\bin;%JAVA_HOME%\jre\bin;


检验：java运行命令，     javac 编译命令


三步走：
1、写源程序：一定要保存
2、编译源程序：javac命令
3、执行程序：java命令

拓展

1、什么叫二进制，二进制和八进制、十进制以及十六进制之间的关系，如何在各种进制之间进行换算
10进制：0  1  2  3  4  5  6  7   8   9 共10个数  
2进制：0  1         101  010  101  010  101  010
8机制：0  1  2  3  4  5  6  7  共8个数 101  010  101  010  101  010 = 525252 
16进制：0  1  2  3  4  5  6  7   8   9  A(10)  B(11)  C(12)  D(13)  E(14)  F(15)
   2          8       
000      0
001      1
010      2
011      3
100      4
101      5
110      6
111      7


 2          16    =2 ^4   
0000      0
0001      1
0010      2
0011      3
0100      4
0101      5
0110      6
0111      7
1000      8
1001      9
1010      A
1011      B
1100      C
1101      D
1110      E
1111      F
0000 0000 0000 0000 0000 0000 0000  0000    0


DOS操作系统：
   1、进入DOS操作系统：两个方式：
windows键+R键 进入“运行”对话框--输入cmd--按ENTER 键进入DOS系统（命令行）


JAVA:
在Windows下进入java源代码所在的文件夹----在地址栏输入“cmd”----按ENTER键进入DOS命令行，直接可以运行javac命令进行编译




   2、dir命令：显示当前文件夹的内容
   3、cd命令：cd 文件夹名  表示进入这个文件夹（举例：cd desktop）
cd.. 表示返回上一层
cd\  表示直接返回当前文件夹所在的根目录  cd\
cd 路径名  表示进入路径最后一个文件夹内（cd c:\users\lenovo\desktop）
   4、如何进入到另一个根目录：根目录名+：  再回车 举例： d：
   5、md命令：创建文件夹  md 路径\文件夹名  再回车

第一个java程序：


程序的概念：为了让计算机执行某些操作或解决某个问题而编写的一系列有序指令的集合 


//在屏幕上输出一句话：hello world!!!
public class HelloWorld{   //类的框架
public static void main(String[] args){    //方法框架，main函数是一个程序的唯一入口
System.out.println("hello world!!!"); 
System.out.println("hello world!!!");     //输出语句
}
}


扩展名：一定要显示扩展名，
win8、10，在打开我的电脑之后，在查看选项卡勾选文件扩展名
win7 在打开我的电脑之后，工具菜单里文件夹选项------>查看选项卡----->隐藏已知文件类型的扩展名，不勾选
编译：
1、进入DOS系统：windows键+r  进入运行窗口--->输入cmd，回车----->DOS系统----找到源文件所在路径--使用javac 文件名.java编译，代码没有错误，就运行----java 文件名，，javac和java后面一定有一个空格
2、在源文件的文件夹位置的地址栏直接输入cmd，回车就可以进入DOS系统，使用javac 文件名.java编译，代码没有错误，就运行----java 文件名，，javac和java后面一定有一个空格


【注意】    1、public修饰的类的类名一定和文件名完全一致，大小写都必须一致
2、一个源文件里面可以有多个类，但是只能有一个public修饰的类
                 3、类名首字符是字母的必须大写



public  公共的，访问修饰符
class  类的关键字，其后紧跟着的就是类名
HelloWorld  类名（命名规则随后写）
static  静态的，表示一加载类，这个方法就进入到内存
void 无返回类型
main()主方法 ，是程序的唯一的入口
String[] args  是main方法的参数，代表的是一个数组，是主方法的形参


{   }   成对出现，一对花括符代表的是一个代码块，  花括符的下一行需要缩进


System.out标准输出设备----屏幕输出，System.in标准输入设备----键盘
；  表示一个语句结束




【注意】代码里的所有符号都必须是英文的


print()和println()的区别：
print()输出后不换行
println()输出后换行


转义符：
\n  输出换行符
\t   输出一个制表位
\"  输出一个双引号
\\  输出斜杠


举例：
梁浩，你好
你好
好的的的的的的的郑智，你好！


练习：输出下面的效果
张三 18


张三18


张三
18
【注意】转义符必须在引号内，不能再外面


注释：


1、单行注释：//
2、多行注释：/* 开头   */结尾
3、文档注释：/**     */   javadoc
举例：
public class Test{
/**
   *文档注释
   *作者：梁浩
   *日期：2016年1月1日
   *输出张三的姓名和年龄
   */
public static void main(String[] args){


/*
多行注释
//输出一句话：张三的姓名和年龄

System.out.print("张三\t18\n\n\t张三18\n\n\t张三\n18");

System.out.print("\n\n\t\t\t郑智，你好！");//输出一句话
*/
}
}


标识符：类名    变量名     方法名（函数）    包名     常量名    工程名
1、只能由字母，$  ,  下划线 ( _ )   数字组成
2、不能以数字开头
3、不能使用关键字
4、见名知意
类名：首字符是字母的要大写，由多个单词组成的时候，每个单词的首字母都要大写（帕斯卡命名法）
变量名：首字符是字母的要小写，由多个单词组成的时候，除了第一个单词之外，后面每个单词的首字母都要大写
（驼峰命名法）
包名：全小写    com.cc.beicai
常量名：全大写    final  int  YEARMONTH  = 12;   final  double  PI  =   3.14159;
工程名：1612day01




变量与常量：
变量：用来表示一个数据的存储空间
    1、全局变量：
    2、局部变量：


数据类型：
    1、基本数据类型：（八种基本数据类型）
整型：byte(字节型   1字节）  short(短整型   2字节)   int （整型  4字节）    long (长整型   8字节)
浮点型：double(双精度浮点型   8字节)    float(单精度浮点型    4字节)
  字符型：char(只能是单个字符   2字节)
布尔型：boolean   （true     false）  1字节



    2、引用数据类型：类类型（String）   数组     接口   占用4字节的空间




如何声明一个变量：
1、数据类型  变量名  =  赋值；
int  age  =  18;
String  name  ="梁浩";
char  sex = '男';
double  englishScore = 99.5;
//使用变量
System.out.println("我的姓名是："+name+"，年龄是："+age+"，我的性别是："+sex+"，我的英语成绩是："+javaScore);


2、数据类型   变量名；
     变量名 = 赋值；
int  age;
age = 18;
int name;
name = "王禹";


运算符与表达式：
1、赋值运算符：=  表示把右边的值赋值给左边的变量，左边不能是常量
int age = 20;
age = 18;//重新赋值
2、拼接符：+  
System.out.println( 14 +"age=" + 12 +20+ age);//   29age=1218
3、算术运算符： 加法+   减法 -     乘法*     除法/     取模% 
  除法/    左边的数除以右边的数，得到的值是两个数相除的商，%取模，左边的数与右边的数相除，取余数
举例：
//需求：有一个三位数，3578  ，我们需要把它的各个位数上值求出来，并相加
//思路：
public class Test3{
public static void main(String[] args){
//声明变量
int sum = 0;//和
int num = 578;//定义一个数
int ge;//个位上的值
int bai;//百位上的值
int shi;//十位上的值


//使用变量求各个位数上的值与和
ge =  num % 10; //个位上的值
shi = num %  100/10; //十位上的值
bai = num /100;  //百位上的值
sum = ge +shi + bai;  //各个位上的数值之和
//输出各个位数上的值之和
System.out.println("sum=" + sum); 
}
}
从控制台输入数据：
1、导包   import java.util.Scanner;
2、Scanner  input = new Scanner(System.in);//创建一个扫描仪对象（变量），并分配一个空间
3、使用：int  num = input.nextInt();


nextInt()   输入一个整数
next()    输入的是一个字符串
nextLine()   输入的是一个字符串
nextDouble()   输入的是一个双精度浮点数
nextFloat()表示单精度浮点数




作业：






4、自增，自减   ++   --  
注意：
自增自减运算符，当他们单独出现的时候，符号在前面和后面都是加1或者减1，但是当他们不是单独出现还参与了其他运算的时候，符号在前面的时候，先自增或者自减，符号在后面的时候，先运算然后变量再自增或者自减。
int  a = 10;
System.out.println(a++);//10     a=11
System.out.println(a++);//11    a=12
//System.out.println(a);
//a= a+1;
a++;//12
System.out.println("a="+a);//12
5、符合运算符：+=   -=   *=    /=   %=
int  a = 10;
a %= 5; //a = a * 5;
System.out.println("a="+a);




-------------------------------2016-12-12-------------------------------------
【新内容】
6、关系运算符：（比较运算符）运算的结果只有两个：true   false 
>   <    ==   !=     >=    <=
int age1 = 20;
int age2 = 26;
System.out.println(age1==age2);//false
System.out.println(20   >   20);


数据类型的转换：
int a = 40;
double   d   =  a;//自动类型转换
System.out.println(d);//40.0


double a = 40.0;
int   d   = （int） a;//报错，强制类型转换
System.out.println(d);//40.0
     
    1）自动类型转换：在由小到大的时候，发生自动类型转换
int 类型------>double   float   long
byte  ----->short   int  long    double  float
short------> int   long  double  float
long ------>double
   2）强制类型转换：由大到小的数据变化的时候，需要进行强制类型转换，但是会损失精度


作业：
1、需求：
      判断一个人的成绩等级，0--60不及格，[60-70)及格，[70-80)良好 [ 80--100]  优秀  小于0或者大于100叫不合法！


88**××※


-----------------2016年12月12日-------------------
测试题：
1、写出下列JAVA语句的编译运行结果，不能通过编译的，注明不能通过编译，并写出原因，否则写出运行结果
1） int a =8,b;
      b =  b + a;      //编译出错，b变量没有初始化，不能参与运算
      System.out.println(b);
2)   int  a = 4,b,c;
      b = a++;//b = 4,a = 5
      c = (b+a)/a++;//c = 1,b = 4 , a = 6
      System.out.println(b);        // 4
      System.out.println(c);         //1
3)   double  n  =  12.8;
      int  m = n++  +  5.8;       //编译出错，int m  = (int)(n++  +  5.8);
      System.out.println(m);
4)   String  str  =  "这是个问题";
      int  a =  12;
      System.out.println(5 + str + a);     //5这是个问题12
5）int  a = 19;
     int b = a/2%5;
     System.out.println(b);     //4
2、请写出8种基本数据类型，以及他们各自占用内存空间的大小


3、什么是编译？什么是解释？
编译：把高级语言编写的源程序整体翻译为目标程序或者机器语言程序
解释：高级语言编写的源程序或者是被编译形成的目标程序，解释一句执行一句，得到结果
4、print()和println()的区别是什么？
都是输出语句，不同点是光标在print()打印输出后不换行，println()打印输出内容之后要换行
5、简述自增自减运算符在变量前面和后面的区别
      1）、当他们单独出现的时候，是单目运算符，符号在前面和后面是一样，都表示自身加1或者减1
      2）、当他们参与了其他的运算的时候，符号在前面的先自增或者自减，之后再参与表达式的运算，符号的后面的时候，变量先参与表达式的运算，然后变量再自增或者自减






------------------2016-12-19------------------------
if(布尔表达式){
执行语句；
}
if(布尔表达式){
执行语句；
}else{
执行语句；
}


if(布尔表达式){
执行语句；
}else  if(布尔表达式){
执行语句；
}else   if(布尔表达式){
执行语句；
}else{
执行语句；
}


if(布尔表达式){
if(布尔表达式){
执行语句；
                }else{
执行语句；
}
}else{
执行语句；
}


if(布尔表达式){
循环语句
}else{
执行语句；
}


switch(表达式){//byte  short  int   char    String  枚举

case  值1：
执行语句1；
break;//
case  值2：
执行语句2；
break;
.
.
.
default:
执行语句2；
break;
}
default语句在case语句前面的时候，break不能省略，当它在最后的时候，break可以省略
每一个case语句后面的break是必不可少的，根据需要可以酌情省略
switch语句能做的，用if语句都可以，反之不一定，比如boolean类型
switch语句用作等值判断
if语句等值判断，区间判断，boolean判断都可以


循环回顾：
while    先判断，再循环，可能一次都不会执行
do  while   先循环，再判断，至少会执行循环一次


for(初始化表达式；布尔表达式；循环变量的变化){
循环体；
}
main（）{//主方法
int a = 1;
while(a<0){
System.out.println("执行了吗？");
}
}


do {
System.out.println("执行了吗？");
}while（a<0）;


for循环和while可以互换
变量的作用域：在哪个{}里定义的就在这个范围内有效，
局部变量：在方法内定义的变量都叫局部变量
全局变量：在方法外定义的变量叫全局变量
全局变量前面加static，就是类变量（属性）




99乘法表的打印


break在二重循环中的使用：标签




函数：就是具有某种功能的独立小程序
访问修饰符   返回值类型   函数名（参数类型  参数1，参数类型  参数2，。。。）{


}
访问修饰符 ：public  static，表示的是访问的权限
返回值类型：就是函数调用之后得到的数据的类型
函数名（方法名）：命名规则和变量一样：sum   avg    max   min   delete
参数类型：就是数据类型（8种基本数据类型和引用类型）
形式参数：参数就是变量，在定义函数（方法）的时候叫形式参数，简称形参
实际参数：调用函数的时候，里面那个参数是具体的数据，这个时候叫实参


需求：求两个未知整数的和






-----------------2016-12-22-------------------------
函数：又叫方法，具有某种独立功能的小程序
语法：访问修饰符  返回值类型  函数名（参数类型   参数1，参数类型  参数2……）{
执行语句（方法体）；
return  表达式；
}
当返回值类型为void的时候，return可以没有
public  static String  show(){
System.out.println("我想去厕所！");
return  "你去吧";
}


有参无返回
有参有返回
无参无返回
无参有返回


【新内容】
数组：
why？？？？为什么要学这个东西？
1、如何保存和使用多名顾客的信息
2、如何打印从键盘上录入的多名学生的成绩
what???
1、概念：
变量是在内存中分配一个合适的内存空间
数组定义：在内存中分配一串合适的内存空间
int[] arr 
int a
数组是一个引用类型
数组的长度是固定的，一旦定义就不能改变


2、数组的声明：声明数组
数据类型[]  数组名；
数据类型  数组名[]；
int[] arr;
String[]  names;
int arr[];


    //数组的标识符就是数组名，用于区别不同的数组；
    //数组元素：数组中存放的数据
    //数组元素有数据类型，可以是基本类型，也可以是引用类型
    //数组有下标，对数组元素进行编号，用来辨别各个不同的数组元素:，下标从0开始
数组长度：arr.length(数组名.length)




3、数组的初始化（赋值）：
数据类型[]  数组名 = new  数据类型[]{元素1，元素2，元素3，元素4……}；//边声明边赋值，静态赋值
new 关键字，就是在堆内存中给数组分配一个合适的空间（创建一个数组对象）
int[] arr = new int[]{10,11,12,13,14};


数据类型[]  数组名 = {元素1，元素2，元素3，元素4……}//边声明边赋值，静态赋值
int[] arr = {10,11,12,13,14}; ;


数据类型[]  数组名 = new  数据类型[数组长度]    //声明数组并分配空间
//自动初始化，输出的值如下："零"值包括：0(整型)、0.0(浮点型)、 \u0000(char)、false(boolean)、null(引用类型)
int[]  arr ;
arr=new int[]{10,11,12,13,14};
int age;
age = 18;


//动态赋值
int[] arr = new int[5];
for(int i = 0;i < arr.length ; i++){
arr[i] = input.nextInt();
}
//问题：如何从键盘上动态的给一个数组赋值
//练习1：从键盘上动态的输入一个班级4名学生的java成绩
//练习2：从键盘上动态的输入一个班级4名学生的姓名
//练习3：从键盘上动态的输入一个班级4名学生的性别
//练习4：从键盘上动态的输入5名客户的会员卡号（4位整数）
//练习5：从键盘上动态的输入5名客户的电话号码
//练习6：从键盘上动态的输入5名客户的初始积分
Scanner input = new Scanner(System.in);
String[] names = new String[4];//创建 数组并分配空间
for(int i = 0;i<names .length;i++){
names [i] = input.next();
}
4、使用数组
打印输出数组：
for(int i = 0;i<arr.length;i++){
System.out.print(arr[i]+"\t");
}
//练习1：输出这个班级4名学生的java成绩
//练习2：输出这个班级4名学生的姓名
//练习3：输出这个班级4名学生的性别
//练习4：输出5名客户的会员卡号
//练习5：输入5名客户的电话号码
//练习6：输入5名客户的初始积分


//综合练习：以表格样式输出这个班级4名学生的姓名，性别和java成绩
//综合练习：以表格样式输出商城全部客户的会员卡号，电话号码和积分


//问题：如何写一个输出数组的函数？
//问题：如何写一个数组赋值的函数？




5、数组数据处理：
1)计算数据：
//需求1：求以上班级的学生的java成绩平均分


2)修改数据：
//需求2：修改第3个学生的java成绩为99
//需求3：修改名叫张三的学生java成绩为59；
//需求4：为会员卡号为1001的客户新增积分2000
//需求5：修改会员卡号为1002的客户电话号码为12345


6、数组排序：
使用java.util.Arrays类，升序排列
import java.util.Arrays;
为数组排序
Arrays.sort(arr);


7、求最值：(打擂台)


8、foreach():仅仅用于遍历数组和集合，不能对元素进行修改，删除等改变数组元素的操作
for (元素类型    变量名    :   集合或者数组名)
{
         // 语句
}
举例：
//输出班级学生的java成绩
for(int a:arr){
System.out.print(a+"\t");
}


----------------------------2016-12-23---------------------


   1、求9+99+999+9999+······[phone] + 99999 99999  =  11111 111100
   2、从键盘上输入一个n，求1+1/2+1/3+1/4+······+1/n
int num = 0;
num = num*10+9
9    =   0*10+9
99 =    9*10+9
999 =  99*10+9
9999 =  999*10+9






【小结】
         数组中常见的两个异常：
int[] arr = new int[3];
System.out.println(arr[3]);//ArrayIndexOutOfBoundsException:
//当访问到数组中不存在的下标时，就会发生该异常。


arr = null;
System.out.println(arr[0]);//NullPointerException
//当引用型变量没有任何实体指向时，还在用其操作实体。就会发生该异常。






1、数组的复制：
1）用循环来复制一个数组

2）使用Arrays.copyof()
int[] arr = {1,2,3,4};
arr = Arrays.copyof(arr,arr.length);
printArr(arr);


这个复制可以复制全部，也可以值复制一部分


System.arrayscopy()也是复制


作用：复制指定的源数组，在指定的位置开始，到目标数组的指定位置 
可用于数组元素的移动
举例：
System.arraycopy(a,1,a1,0,3);
     a：代表原数组
     1：代表从a数组下标1开始
     a1：表示新的数组
     0：表示复制到a1数组的0下标开始
     3：表示复制元素的个数


int[] arr = new int[]{1,2,3,4,5,6}
int[] arr1 = new int[6];
System.arrayscopy(arr,3,arr1,0,4)//4 5 6 0 0 0


2、数组的扩容：
//需求1：用一个长度为5的字符串数组保存了一个5首歌曲，现在我新下载了一首歌曲放进去，怎么做？


//需求2：从一个数组中删除一个元素，并把后面的元素移动1个位置，使中间没有元素为空
               String[] a = new String[]{"a","b","c","d","e","f"};


3、二维数组：


二维数组本质上是以数组作为数组元素的数组，即“数组的数组”。
下面是个实例
类型说明符 数组名[常量表达式][常量表达式]
例如：
float a[3][4],b[5][10];
定义a为3*4（3行4列）的数组，b为5*10（5行10列）的数组。注意，不能写成
float a[3,4],b[5,10];




4、冒泡排序：
冒泡排序是一种交换排序。


什么是交换排序呢？


交换排序：两两比较待排序的关键字，并交换不满足次序要求的那对数，直到整个表都满足次序要求为止。
它重复地走访过要排序的数列，一次比较两个元素，如果他们的顺序错误就把他们交换过来。走访数列的工作是重复地进行直到没有再需要交换，也就是说该数列已经排序完成。


这个算法的名字由来是因为越小的元素会经由交换慢慢“浮”到数列的顶端，故名。


假设有一个大小为 N 的无序序列。冒泡排序就是要每趟排序过程中通过两两比较，找到第 i 个小（大）的元素，将其往上排。


假设要对一个大小为 N 的无序序列进行升序排序（即从小到大）。 


(1) 每趟排序过程中需要通过比较找到第 i 个小的元素。


所以，我们需要一个外部循环，从数组首端(下标 0) 开始，一直扫描到倒数第二个元素（即下标 N - 2) ，剩下最后一个元素，必然为最大。


(2) 假设是第 i 趟排序，可知，前 i-1 个元素已经有序。现在要找第 i 个元素，只需从数组末端开始，扫描到第 i 个元素，将它们两两比较即可。


所以，需要一个内部循环，从数组末端开始（下标 N - 1），扫描到 (下标 i + 1)。
代码示例：
public void bubbleSort(int[] list) {
    int temp = 0; // 用来交换的临时数
 
    // 要遍历的次数
    for (int i = 0; i < list.length - 1; i++) {
        // 从后向前依次的比较相邻两个数的大小，遍历一次后，把数组中第i小的数放在第i个位置上
        for (int j = list.length - 1; j > i; j--) {
            // 比较相邻的元素，如果前面的数大于后面的数，则交换
            if (list[j - 1] > list[j]) {
                temp = list[j - 1];
                list[j - 1] = list[j];
                list[j] = temp;
            }
        }
 
        System.out.format("第 %d 趟：\t", i);
        printAll(list);
    }
}


创建源程序
编译源程序
执行