------- <a href="http://www.itheima.com" target="blank">android培训</a>、<a href="http://www.itheima.com" target="blank">java培训</a>、期待与您交流！ ----------
Java基础
软件：一系列按照特定顺序组织的计算机数据和指令的集合，软件的出现实现了人与计算机之间更好的交互。
交互方式：
图形化界面：这种操作方式简单直观，使用着易于接受，容易上手操作。
命令行方式：需要一个控制台，输入特定的指令，让计算机完成一些操作。较为麻烦，需要记住一些指令
课程中常见的dos命令：
dir：列出当前目录下的文件及文件夹
md：创建目录
rd：删除目录
cd：进入指定的目录
cd..：退回到上级目录
cd/：退回到根目录
del：删除文件
exit：退出dos命令行
Java语言概述
是SUN(Stanford University Network，斯坦福大学网络公司)1995年推出的一门高级编程语言。
是一种面向Internet 的编程语言
随着java技术在web方面的不断成熟，已经成为web程序的首选开发语言
简单易学，完全面向对象，安全可靠
JRE(Java Runtime Environment Java运行环境)
包括Java虚拟机(JVM Java Virtual Machine)和Java程序所需的核心类库等，如果想要运行一个开发好的Java程序，计算机中
只需要安装JRE即可。
JDK(Java Development Kit Java开发工具包)
JDK是提供给Java开发人员使用的，其中包含了java的开发工具，也包括了JRE。所以安装了JDK，就不用在单独安装JRE了。
什么时候需要配置path，什么时候需要配置classpath
我们想要执行javac命令，必须切换到这个命令所在的目录下才能执行，这样执行比较有局限性，为了方便于执行所有java提供
的工具，可以把这个工具所在的路径告诉系统，由windows帮我们去找要执行的命令，这样操作会更简单，所以需要配置path。
class文件是java的运行文件，想要在任意目录下都可以执行某一目录下的class文件，根据path环境变量的原理，可以定义一
个名为classpath的环境变量，将要运行的class文件目录定义在该变量中。
classpath变量的值是java类文件的目录
path变量的值是windows程序文件的目录
Java中的名称规范
包名：多个单词组成时所有字母都小写
类名或接口名：多单词组成时，所有单词首字母都大写
变量名和函数名：多单词组成是，第一个单词首字母小写，第二个单词开始每个单词首字母大写
所有字母都大写，多单词是每个单词间用下划线连接
Java语法演示
class demo2
{
public static void main(String[] args)
{
char ch='a';
System.out.println('9'+2);
int a=3,b;
b=a++;
System.out.println("a="+a+','+ "b="+b);
/*
转义字符；通过\来转变后边字母或符号的含义；
\n 换行
\b 退格 相当于backspace
\r 按下回车键 windows系统下，回车符是由两个字符\r\n组成
\t 制表符 相当于Tab键
*/
System.out.println("hello \t java");
System.out.println("\\hello java\\");
/*
逻辑运算符用于连接boolean类型的表达式
*/
/*
^ : 异或
true^true=false;
true^false=true;
false^true=true;
false^false=false;
*/
/*
>> :最高位补什么由原有数据的最高位决定
如果最高位是0，右移后用0补空位
如果最高位是1，右移后用1补空位
>>> 无论最高位是什么，右移后都用0补
*/
System.out.println(6 & 3);
System.out.println(6 | 5);
System.out.println(6 ^ 5);
//System.out.println(Integer.toBinaryString(60));
int num=60;
//获取60的最低4位，通过&15
int n1= num &15 ;
System.out.println(n1>9 ? (char)(n1-10+'A') :n1);
//获取下一组四位，将60右移4位
int temp = 60 >> 4;
//对temp的值进行最低4位的获取
int n2= temp & 15;
System.out.println(n2 > 9 ? (char)(n2-10+'A') : n2);
int x = 3, y;
y = (x>1) ? 100 : 200;
System.out.println("y="+y);
x=3;
if(x>1)
System.out.println('a');
if ( x>2)
System.out.println('b');
if (x>3)
System.out.println('c');
else
System.out.println('d');
x=15;
if ( x==3 || x==4 || x==5)
System.out.println(x+"春季");
else if ( x== 6 || x==7 || x==8 )
System.out.println(x+"夏季");
else if ( x==9 || x==10 || x==11 )
System.out.println(x+"秋季");
else if ( x==12 || x==1 || x==2 )
System.out.println(x+"冬季");
else
System.out.println("输入有误");
x=4;
switch ( x )
{
case 3:
case 4:
case 5:
System.out.println("春季");
break;
case 6:
case 7:
case 8:
System.out.println("夏季");
break;
case 9:
case 10:
case 11:
System.out.println("秋季");
break;
case 12:
case 1:
case 2:
System.out.println("冬季");
break;
default :
System.out.println("错误");
}
/*
if 和switch语句很像
具体什么场景下，用什么语句呢
如果判断的具体数值不多，并且符合 byte short int char 四种类型
虽然两个语句都可以使用，建议用switch语句，以为效率稍高
其他情况 ：对区间判断，对结果为boolean型判断，使用if ，if的使用范围更广
*/
}
}
class demo3
{
public static void main(String[] args)
{
/*
定义初始化表达式
while(条件表达式)
{
循环体（执行语句）
}
*/
int x=1;
while( x <= 10 )
{
System.out.println("x="+x);
x+=2;
}
do
{
System.out.println("do :x="+x);
x++;
}while(x<=10);
System.out.println("x==="+x);
/*
1）变量有自己的作用域，对于for来讲，如果将用于控制循环的变量定义在for语句中，那么变量只在for语句中有效，
for语句执行完毕，变量在内存中释放
2）for语句和while语句可以互换，如果需要定义循环增量，用for更合适
变量只为控制循环的增量而存在，用for语句，内存会稍微优化
*/
/*
for( int y=3; y<10; y++)
{
System.out.println("y="+y);
}
System.out.println("y==="+y);
*/
x=1;
for(System.out.println("a"); x<3; System.out.println("c"))
{
System.out.println("d");
x++;
}
/*
无线循环的最简单变现形式
for( ; ;) {}
while( true ) {}
*/
}
}
/*
1 获取1~10的和，并打印
*/
/*
1~100之间，7的倍数的个数，并打印
思路：
1，先对1~100进行遍历，通过循环的形式。
2，在遍历的过程中，定义条件，只对7的倍数进行操作。
3，因为7的倍数不确定，只要符合条件，就通过一个变量记录变化的次数。
步骤：
1，定义循环语句，选择for语句。
2，在循环中定义判断，只要是7的倍数即可，使用if语句，x%7==0。
3，定义变量，该变量随着7的倍数出现而自增。
*/
class Test
{
public static void main(String[] args)
{
int sum=0;
for ( int x=1 ; x<=10 ; x++ )
{
sum+=x;
System.out.println("sum="+sum);
}
System.out.println( "sum="+sum );
int count=0;
for( int x=1; x<=100 ; x++)
{
if(x%7==0)
{
System.out.println("x="+x);
count++;
}
}
System.out.println("count="+count);
/*
累加思想：通过变量记录循环操作后的结果，通过循环的形式，进行累加的动作。
*/
/*
计数器思想：通过一个变量记录数据的状态变化，也许通过循环完成
*/
}
}
class forfordemo
{
public static void main(String[] args)
{
for( int x=0; x<3; x++)
{
for( int y=0; y<4; y++)
{
System.out.print("*");
}
System.out.println(); //只有一个功能，换行
}
/*
**********
*********
********
*******
******
*****
****
***
**
*
发现图形有很多行，每一行有很多列
使用嵌套循环
*/
// int z=10;
w: for( int x=0; x<10; x++)
{
q: for( int y=x; y<10; y++)
{
System.out.print("*");
}
System.out.println();
// z--;
}
for( int x=0; x<10; x++)
{
for( int y=0; y<=x; y++)
{
System.out.print("*");
}
System.out.println();
}
/*
九九乘法表
*/
for( int x=1; x<9; x++)
{
for( int y=1; y<=x; y++ )
{
System.out.print(y);
}
System.out.println();
}
for( int x=1; x<10; x++)
{
for(int y=1; y<=x; y++)
{
System.out.print(y+"*"+x+"="+y*x+"\t");
}
System.out.println();
}
//continue 只能作用于循环结构。继续循环 特点：结束本次循环，进行下次循环
w : for( int x=1; x<10; x++)
{
if(x%2==1)
continue;
System.out.print("x="+x+'\t');
// continue w;
}
/*
记住：
1，continue 和 break的作用范围
2，break和continue单独存在时，下面可以有任何语句，下边都执行不到
*/
System.out.println();
for( int x=0; x<10; x++)
{
for( int y=x+1; y<10; y++)
{
System.out.print(" ");
}
for( int z=0; z<=x; z++)
{
System.out.print("* ");
}
System.out.println();
}
}
}
class Fuction
{
public static void main(String[] args)
{
getValue(4);
compare( 4, 4 );
add(4,5);
add(4,5,6);
print99(6);
}
public static void getValue( int x)
{
System.out.println(x*3+5);
return;
}
// 函数内部只能调用函数，不能定义函数
/*
如何定义函数？
1，既然函数是一个独立的功能，那么该函数的运算结果是什么先明确
2，再明确定义该功能的过程中，是否需要未知的内容参与运算
*/
// 需求：定义一个功能，完成3+4的运算，并将结果返回给调用者
/*
1，明确功能的结果：是一个整数的和
2，在实现的过程中，没有未知的内容参与运算
其实这两个功能就是在明确函数的定义
1，是明确函数的返回值类型
2，是明确函数的参数列表（参数类型和参数个数）
*/
public static boolean compare( int a , int b )
{
return (a==b) ? true : false;
}
// 当定义的功能不同，但参与运算的未知内容不同
// 这时定义一个函数名称以表示功能，方便阅读，而通过参数列表的不同来区分多个同名函数
public static int add( int a,int b)
{
return a+b;
}
public static int add( int a, int b, int z)
{
return a+b+z;
}
public static void print99( int num)
{
for( int x=1; x<num; x++)
{
for( int y=1; y<=x; y++)
{
System.out.print(x+"*"+y+"="+x*y+"\t");
}
System.out.println();
}
}
// 栈数据使用完毕，会自动释放
//
}
class ArrayDemo
{
public static void main(String[] args)
{
// int [] arr = new int [3];
// System.out.println(arr[2]);
int [] arr = {3,4,5,6,7,8};
System.out.println("length="+arr.length);
// 遍历数组中的每个元素，并求和
int sum=0;
for( int x=0; x<arr.length; x++)
{
System.out.println("arr["+x+"]"+"="+arr[x]);
sum += arr[x];
}
System.out.println("sum="+sum);
printArray(arr);
int Max=getMax(arr);
System.out.println("Max="+Max);
int Min=getMin(arr);
System.out.println("Min="+Min);
System.out.println(arr);
//布尔型数组的默认值是false
boolean [] ar= new boolean [3];
System.out.println(ar[1]);
}
// 遍历数组中的元素，并打印
public static void printArray(int [] arr)
{
for(int x=0; x<arr.length; x++)
{
if (x!=arr.length-1)
System.out.print(arr[x]+",");
else
System.out.println(arr[x]);
}
}
// 取得最大值
public static int getMax( int [] arr)
{
int max=arr[0];
for( int x=1; x<arr.length; x++)
{
if ( arr[x]>max)
max=arr[x];
}
return max;
}
// 获取最大值得另一种方法
// 可以将变量初始化为0，这种方式其实是初始化数组中任一个角标
public static int getMin( int [] arr)
{
int min=0;
for ( int x=1; x<arr.length; x++)
{
if( arr[x]<arr[min])
min=x;
}
return arr[min];
}
/*
获取double类型数组的最大值，因为功能一致，所以定义相同的函数名称，以重载的形式存在
public static double getMax( double [] arr )
{
}
*/
}
/*
对给定数组排序
{2,4,8,5,3,7,6}
*/
class ArrayTest1
{
// 选择排序
public static void selectsort(int [] arr)
{
for( int x=0; x<arr.length-1; x++)
{
for ( int y=x+1; y<arr.length; y++)
{
if ( arr[x]>arr[y])
{
/*
int temp=arr[x];
arr[x]=arr[y];
arr[y]=temp;
*/
swap(arr,x,y);
}
}
}
}
// 冒泡排序
public static void bubblesort(int [] arr)
{
for( int x=0; x<arr.length; x++) // for(int x=arr.length-1; x>0; x--)
{ // for( int y=0; y<x; y++)
for( int y=0; y<arr.length-1-x; y++) //-x: 让每一次比较的元素减少；-1：避免下表越界
{
if(arr[y]>arr[y+1])
{
/*
int temp=arr[y];
arr[y]=arr[y+1];
arr[y+1]=temp;
*/
swap(arr,y,y+1);
}
}
}
}
// 交换
public static void swap( int [] arr, int a, int b )
{
int temp=arr[a];
arr[a]=arr[b];
arr[b]=temp;
}
// 打印数组
public static void printArray( int [] arr)
{
for(int x=0; x<arr.length; x++)
{
if ( x!=arr.length-1)
System.out.print(arr[x]+",");
else
System.out.println(arr[x]);
}
}
public static void main(String[] args)
{
int [] arr = {2,4,8,5,3,7,6};
// 排序前
printArray(arr);
System.out.println();
//排序
//selectsort(arr);
bubblesort(arr);
// 排序后
printArray(arr);
}
}
/*
数组的查找操作
*/
class ArrayTest2
{
public static void main(String[] args)
{
int [] arr= {2,4,5,7,19,32,49};
//int index=getIndex(arr,4);
int index=halfsearch(arr,3333);
System.out.println("index="+index);
}
// 折半查找可以提高查找效率，但必须要保证该数组是有序的数组
public static int halfsearch( int [] arr, int key)
{
int min, max, mid;
min=0;
max=arr.length-1;
mid=(min+max)/2;
while(arr[mid]!=key)
{
if(arr[mid]>key)
max=mid-1;
else if(arr[mid]<key)
min=mid+1;
if(min>max)
return -1;
mid=(min+max)/2;
}
return mid;
}
//折半的第二种方式
public static int halfsearch_2(int [] arr, int key)
{
while(min<=max)
{
min=(min+max)>>1;
if(key>arr[mid])
min=mid+1;
else if(key<arr[mid])
max=mid-1;
else
return mid;
}
return -1;
}
// 定义功能，获取key第一次出现在数组中的位置。如果返回-1，表示该key在数组中不存在。
public static int getIndex(int [] arr, int key)
{
for(int x=0; x<arr.length; x++)
{
if(arr[x]==key)
return x;
}
return -1;
}
}
class ArrayTest3
{
public static void main(String[] args)
{
toBin(6);
System.out.println();
toHex(60);
toHex_1(-60);
toBin_1(60);
toHex_2(60);
toOx(60);
}
/*
十进制-->二进制
*/
public static void toBin( int num)
{
StringBuffer sb= new StringBuffer();
while(num>0)
{
//System.out.print( num%2);
sb.append(num%2);
num=num/2;
}
System.out.print(sb.reverse());
}
/*
十进制-->十六进制 0000-0000 0000-0000 0000-0000 0011-1100
*/
public static void toHex( int num)
{
StringBuffer sb= new StringBuffer();
for(int x=0; x<8; x++)
{
int temp= num&15;
if(temp>9)
//System.out.print((char)(temp-10+'A'));
sb.append((char)(temp-10+'A'));
else
//System.out.println(temp);
sb.append(temp);
num=num>>>4;
}
System.out.println(sb.reverse());
}
/*
0 1 2 3 4 5 6 7 8 9 A B C D E F 十六进制中的元素
0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15
查表法： 将所有的元素临时存储起来，建立对应关系
每一次&15的值作为索引去查建立好的表，就可以找到对应的元素
*/
public static void toHex_1(int num)
{
char [] chs= {'0','1','2','3','4','5','6','7','8','9','A','B','C','D','E','F'};
//定义一个临时容器
char [] arr= new char[8];
int pos=arr.length;
while(num!=0)
{
int temp= num&15;
//System.out.print(chs[temp]);
arr[--pos]= chs[temp];
num=num>>>4;
}
for(int x=pos; x<arr.length; x++)
{
System.out.print(arr[x]);
}
System.out.println();
}
public static void trans( int num, int base, int offset)
{
if(num==0)
{
System.out.println(0);
return;
}
char [] chs= {'0','1','2','3','4','5','6','7','8','9','A','B','C','D','E','F'};
char [] arr= new char[32];
int pos = arr.length;
while(num!=0)
{
int temp=num&base;
arr[--pos]=chs[temp];
num=num>>>offset;
}
for(int x=pos; x<arr.length; x++)
{
System.out.print(arr[x]);
}
System.out.println();
}
public static void toHex_2(int num)
{
trans(num,15,4);
}
public static void toBin_1(int num)
{
trans(num,1,1);
}
public static void toOx(int num)
{
trans(num,7,3);
}
}
扫一扫
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
