Java基础语言主成:
Java语言开发的规范:
1.1关键字
1.2标识符
由英文字母大小写组成,数字:0-9符号:-$
定义法则:1,数字不可以开头
2,关键字不能作为标识符
1.3注释
表示://单行注释
/*
*/:多行注释
注释包含的方面
重点内容:
1.需求
2.思路:
3步骤
思路 :
1,定义一个类,因为Java程序都定义在类中,Java程序都是以类的形式存在的,类的形式其实就是一个字节码文件的最终的体现
2,定义一个主函数。为了能够让该类进行独立运行
3,演示hello world,在控制台上看到字样,故需要使用输出语句运行。
代码仅仅是思想的一种体现。
步骤:
用class关键字来进行类的定义,取个类名
用主函数:public static void main(String[] agrs);固定格式。jvm认识
因需要将其hello world输出到控制台上,故需要使用输出语句完成。
class Dmeo{
//定义一个主函数
public static void main(String[] args){
//输出语句,用括号将其打印其控制台上,
System.out.println("hello World");
}
}
1.4常量与变量
常量的类型:
1.4.1:
整数常量,
小数常量,
布尔值常量(boolean){只有true,false},
字符常量
字符串常量,
null常量(只有一个值:null)
变量:
1内存中的一个区域,
2该区域有自己的名称(变量名)和类型(数据型
3该区域的数据可以在同一类型范围内不断变化
为什么定义变量:
用来存放同一类型的常量,并可以重复使用;
格式:
*重点内容:
数据类型 变量名 = 初始值;*
数据类型 :基本数据类型和引用数据类型
基本数据类型:
1.1数值型:整数(byte,short,int,long),浮点(float,double),
字符(char),布尔(boolean);
1.2引用类型:类(class),接口(interface),数组([])
整数默认,int,小数默认:double
数据类型的自动转换:
1.5运算符
算术运算符,(+ -,*,/)
赋值运算符,
比较运算符,(==,!=,<,>,<=,>=,instanceof(检查是否是类的对象));
逻辑运算符(&,|,^,!,&&,||)
&:(false&true)=false;
|:(false|true)=true;
^:(false^false);
!:(not(非)){!true}=false;
/*&与&&(短路)的区别:
结果是一样的,但运算过程有点区别
&:无论左边的运算结果是什么,右边都参与运算;
&&:当左边为false,右边不参与运算。
比如:
x=1;
x>2&x<5:false;(需要同时运算);
x>2&&x<5:false;(运算一边就可以了既可以得出);
&&:false&&true = false;
||:OR:(false||true) =true;
|与||的区别:跟&和&&的区别是一样的;
位(二进制运算)运算,
<<(左移)
右移
无符号右移
&与运算(6&3=2)
|或运算(6|3=7)
^异或运算
~反码(基本不做运算)
异或运算:一个数异或同一个数两次,结果还是这个数。
最有效的运算方式(位运算):算出2*8的整数
:交换两个数的数值(不用第三方变量值);
class {
public static void main(String[] agrs){
//最有效率的方式算出2*8 = 16
System.out.println("2<<3");
//计算两个数的互换值
int a=3,b=5;
//对两个整数变量的值进行变换(不需要第三方量)
/*
int c ;
c = a;
a = b;
b = c;
*/
//不能用,两整数数值过大,会超出范围
a = a + b;
b = a - b;
a = a - b;
//位运算(最快)面试时用
a = a ^ b;
b = a ^ b;
a = a ^ b;
}
}
三元运算符
(条件表达式)?表达式1:表达式2;
如果条件为true,运算为表达式一,否则为表达式2;
1.6语句
判断语句,选择结构,循环结构
/*
if语句的第一种格式;
1,
if(条件表达式)
{
执行语句;
}
*/
int x = 3;
if(true){
System.out.println("yes");
}
/*
if(条件表达式)
{
执行语句 ;
}
else if(条件表达式)
{
执行语句;
}
else if(条件表达式)
{
执行语句;
}
else
{
执行语句;
}
*/
//
class IfTest{
public static void main(String agrs[]){
}
}
//提示用户输入一个整数,如果该数字是5的整数倍,打印HiFive。如该
//数字能被2整除,打印HiEven。
switch语句:
格式:
switch(表达式)
{
case:取值1:
执行语句;
break;
case:取值2:
执行语句;
break;
case:取值3:
执行语句;
break;
....
default:
执行语句;
break;
}
System.out.println("Hello World");
if与switch的区别:优缺点,应用场景。
if:
1//对具体的值进行判断。
2,//对区间判断。
3,//对运算结果是boolean类型的表达式进行判断。
switch:
1//对具体的值进行判断。
2//值得个数通常是固定的
//对于几个固定的值判断,建议使用switch语句,因为switch语句会将
//具体的答案都加载进内存。
1.6.3
循环结构:while,do while ,for.
while 语句格式:
while(条件表达式){
执行语句;
}
do while 语句格式:
do{
执行语句;
}while(条件表达式);
do while 特点:
是条件无论如何是否满足,
循环体至少执行一次。
class WhileTest{
public static void main(String[] args)
{
/*
练习1到10的练习
思路:
每次参与的运算的数值不确定。
每次出现的和数据也不确定;
每次参与的加法运算的值有递增规律;
每次都是加法运算在重复,并且都是和加下一个数值。
*
/
do{
int i = 1;
int sum = 0;
sum = sum +i;
i++;
}while(i<=10)
}
}
int x = 1;
int sum = 0;
while(x < = 10)
{
sum = sum + i;
i++;
}
/*
思路:
首先设置一个变量来统计6的倍数的出现的次数;
遍历1-100范围,用判断语句来判断6的倍数的整数,并记录其个数;
int x = 1;
int count = 0;
while(x < = 100)
{
if (x % 6 ==0)
count ++;
System.out.println("x = :"+ x);
x++
}
System.out.println("count ="+ count);
*/
循环结构:
格式:
for(初始表达式;循环表达式;循环后的操作表达式)
{
执行循环语句;
}
for 与 while 的特点:
1,for 和 while 可以互换;
2,格式上的不同,在使用上有点小区别;
如果需要通过变量来对循环进行控制,
//while(true){};无限循环最简单的表达式;
//什么时候使用循环结构,
//当对某些代码执行很多次时,使用循环结构完成;
//当对一个条件进行一次判断时,可以使用if语句;
//当对一个条件进行多次判断时,也可以使用while语句;
注意:
在使用循环时,一定要明确哪些语句需要参与循环,那些不需要;
循环通常需要控制条件,需要控制其范围;
for (int x = 0; x< = 4;x++)
{
for(int y = 0; y < = 5;y++)
{
System.out.println("*");
}
System.out.println();
}
/*
九九乘法表:
1*1 = 1;
1*2 = 2; 2*2 = 4;
for(int x = 1; x<= 9;x++)
{
for(int y = 1; y < = x; y++)
{
System.out.println(y + "x" + x +"="+y*x + "");
}
System.out.println();
}
*/
/*
\n:回车符:
\t:制表符:
\b:表格:
\r:按下回车键。
windows系统中回车符其实是由两个字符的\r\n;
linux中回车符是 \n.
*/
//打印
* * * * *
* * * *
* * *
* *
*
for(int x = 1; x < =5 ; x ++)
{
for(int y = 1 ;y < x ; y ++)
{
System.out.print("-");
}
for( int z = x ; z < = 5;z++)
{
System.out.print("*");
}
System.out.println();
}
break(跳出),continue(继续)
brreak语句:应用范围:选择结构和循环结构。
continue语句:应用于循环结构。
注意:
a,这两个语句离开应用范围,存在是没有意义的
b,这两个语句单独存在下面都不可以有语句,因为执行不到。
c,continue语句是结束本次循环继续下次循环。
d,标号的出现,可以让这两个语句作用于指定范围
/*
break:跳出。
break作用的范围:要么是switch语句,要么是循环语句。
记住:当break语句单独存在时,下面的不要定义其他语句,因为执行不到;
break跳出当前循环。
如果出现了的循环嵌套,break想要跳出指定的循环,可以通过标号来完成;
for( int x = 0; x <3;x++)
{
for(int y = 0;y < 4; y++)
{
System.out.println("x="+x);
break;
}
}
/*
continue:继续。
作用的范围:循环结构。
continue:结束本次循环,继续下次循环。
如果continue单独存在时,下面不要有任何语句,因为执行不到;
*/
for(int x = 0; x < = 11;x ++)
{
if(x%2==0)
continue;
System.out.println("x="+x);
}
xiaoqiang:for(int x = 0;x <3;x++)
{
wangcai:for(int y = 0; y<4;y++)
{
System.out.println("x="+x);
continue xiaoqiang;
}
}
*/
1.7函数
函数的概念:
1.函数就是定义在类中的具有特定功能的独立小程序;
2函数也称为方法。
函数格式的格式:
//函数名字必须要可读性;
修饰符 返回值类型 函数名(参数类型 形式参数1,参数类型 形式参数2,…)
{
执行语句;
return 返回值;
}
//特殊情况:
功能没有具体的返回值。
这时return的后面直接用分号结束。
返回值类型怎么体现呢,因为没有具体值,所以不可以写具体的数据类型
在java中只能用一个股关键字来表示这种情况,关键是:void。
总结:没有具体返回值时,返回类型用void来表示。
注意:如果返回值类型void,那么函数中的return省略不写。
函数的特点:
定义函数可以将功能代码进行封装
便于对该功能进行复用
函数只有被调用时才会被执行
函数提高了代码的复用性
对于函数没有具体返回值的情况,返回值类型用关键字void表示,那么该函数中的return语句如果在最后一行可以省略不写
注意:
函数只能调用函数,不可以在函数内部定义函数。
定义函数时,函数的结果应该返回给调用者,交由调用者处理。
public static int add(int a,int b){
return a + b;
}
//定义一个功能,完成两个整数的和的获取。
思路:既然定义功能,就是可以用函数来实现。
如何定义一个函数
通过两个明确来完成。
明确一:这个函数的结果是什么?
是和。功能的结果,所以该功能的返回值类型是int。
明确二:这个函数的功能实现是否需要未知内容参与运算
有,加数和被加数,这就是函数的参数列表(参数的个数,参数的类型)
public static int add(int a,int b){
int sum = a+b;
return sum;
}
//需求1:定义一个功能,画一个矩形在控制台;
/*
思路:明确一:这个函数的结果是什么?
没有结果,因为直接打印到了,控制台,并未返回给调用者。
用void表示;
明确二:这个函数的功能实现是否需要未知内容参与运算
有,行和列不确定。两个。整数 int
public static void draw()
{
for(int x = 1; x < row ;x++ )
{
for(int y = 1;y < col;y++){
System.out.print("*");
}
System.out.println();
}
return;
}
需求3:定义一个功能,比较两个数的是否相等。
思路:有结,只是比较两数大小,用boolean值,并返回给调用者;
这函数实现其功能需要未知两个数的进行比较运算;并返回结果。
public static blooean equals(double a,double b){
if(a == b){
return true;
}else
{
return false;
}
}
*/
// 函数的重载;
重载的概念
在同一个类中,允许存在一个以上的同名函数,只要它们的参数个数或者参数类型不同即可
重载的特点:
与返回值类型无关,只看参数列表。
重载的好处:
方便于阅读,优化了程序设计。
//返回两个整数的和
int add(int x,int y){return x+y};
//返回三个数的最小和
int add(int x,int y,int z){return x+y+z};
1.8数组
//数组的定义
概念:同一个类型数据的集合。其实就是一个容器。
数组的好处
//可以自动给数组中的元素从0开始编号,方便操作这些元素。
格式1:
元素类型[] 数组名 = new 元素类型[元素个数或数组的长度];
示例:int [] arr = new int [5];
格式2:
元素类型[] 数组名 = new 元素类型[]{元素,元素,元素……};
int [] arr = new int []{3,5,1,7};
int [] arr = {3,4,5,7};
/*
内存的划分:
1.寄存器。
2本地方法区
3方法区
4栈内存
//存储的都是局部变量
而且变量所属的作用域一旦结束,该变量就自动释放。
5堆内存
存储的是数组和对象(其实数组都是对象)凡是new,建立在堆中。
特点:1,每一个实体都有首地址值。
2,堆内存中的每一个变量都有默认初始化值,根据类型的不同而不同。整数是0,小数0.0或者0.0f
3,垃圾回收机制。
*/
“`
class ArrayDemo2
{
public static void main(String[] agrs)
{
//格式1
/*
需要一个容器,但是不明确容器的具体数据。
*/
int [] arr = new int[3];
// arr = null;
System.out.println(arr);
//当引用型变量没有任何实体指向时,还在用其操作实体,就会发生异常;
/*
需要一个容器,存储已经的具体数据。
*/
//无论那门语言,遇到容器重点学;
//int [] arr = new int[]{89,34,470,17};
/*
对数组操作最基本的动作就是存取;
核心思想:就是对角标的操作;
*/
}
}
//数组的常见的操作;
//获取数组中的最大值。
思路:
1,需要进行比较。并定义变量及记录每次比较后的最大值。
2,对数组中元素进行遍历取出,和变量中记录的数值进行比较。
3,遍历结果,该变量记录就是最大值。
//当其数组中的数值为负数时,故有问题。
public static int getMax(int [] arr){
int max = 0;
for(int x = 0;x