1.if…,else…和三元运算符的区别(面试题)
共同点: 都是针对两种情况进行判断,都有表达式;
不同点: if…else…流程控制语句,范围很大,不仅仅可以操作数据值,还可以操作输出语句进行去完成逻辑判断;而三元运算符仅仅是运算符,操作两个具体的数据值;
***三元运算符能实现的一定可以用if...else...来实现,但是if...else...能实现的不一定可以用三元.***
举例:(输入一个数,判断是否为偶数?)
//导包
import java.util.Scanner;
class Demo{
public static void main(String[] args){
//录入两个数
Scanner sc=new Scanner(System.in);
System.out.print("请输入一个数:");
int a=new Scanner(System.in);
//if
if(a%2==0){
System.out.print("这个数是偶数");
}else{
Syste.out.print("这个数是奇数");
}
//三元
String msg = (a%2?"偶数":"奇数");
System.out.print(msg);
}
}
2.if…else…嵌套
格式
if(条件判断1){
条件成立,继续判断2/执行语句1
if(条件判断2){
执行语句2
}else{
执行语句3
}
}else{
if(条件判断1){
条件成立,继续判断2/执行语句1
}
if(条件判断2){
执行语句2
}else{
条件不成立
执行语句1
}else{
执行语句2
}
}
举例(输入三个数比较大小)
import java.until.Scanner ;
class Demo2{
public static void main(Stringg[] args){
Scanner.sc=new Scanner(System.in);
//录入san个数
for(int i=1; i<4; i++){
System.out.println("请输入"+i+"个数:")
i = sc.nextInt();
}
if(a<b){
if(b>c){
int max=b;
}else{
int max=c;
}
}else{
if(a>c){
max=a;
}else{
max =c;
}
}
System.out,println("最大的数是"+max);
}
3.流程控制语句之switch(考点)
格式
swith(变量名){
case 值1:
语句1;
break;
case 值2:
语句2;
break;
…
default:
语句n;
break;
}
执行流程: swith后面的变量需要和case进行匹配,case 值1成立;执行语句1;遇见break,swith语句结束; 如果不匹配,继续执行case 值2,遇见break结束;
举例(录入一个值,判断是星期几?)
//导包
import java.util.Scanner ;
calss Demo3{
public static void main{
//录入
Scanner.sc=new Scanner(System.in);
System.out.print("请输入一个数:");
int a =sc.nextInt();
swith(a){
case 1:
System.out.println("星期一");
break;
case 2:
System.out.print("星期二");
break;
case 3:
System.out.print("星期三");
break;
case 4:
System.out.print("星期四");
break;
case 5:
System.out.println("星期五");
break;
case 6:
System.out.println("星期六");
break;
case 7:
System.out.println("星期日");
break;
default:
System.out.println("对不起,输入不合格.")
break;
}
}
}
4.循环结构语句
1)for循环
格式
for(初始化语句; 条件判断表达式;控制体语句){
循环体语句;
}
举例(输出同样的五句话)
class Demo4{
public static void main(String[] args){
for(int a =0; a<5; a++){
System.out.println("HellloWorld")
}
}
}
2)while循环
格式
while(条件表达式){
循环体语句;
控制体语句;
}
举例
class Demo5{
public static void main(String[] args){
int i=0;
while(i<5){
System.out,println("HelloWord")
}
}
}
3)do-while循环
格式
do{
循环语句;
控制体语句;
}while(条件表达式);
特点
和for,while的最大区别是即使循环体不成立,循环体至少执行一次!
举例(输出五句话)
class Demo6{
public static void main(String[] args){
int a=5;
do{
System.out.println("HeeloWorld");
a++;
}while(a<5);
}
}
3)死循环
①for
格式
for(;; ){
循环体语句;
}
②while(推荐)
格式
while(ture){
循环体语句;
}
break;中断测试
5.for循环嵌套
格式
for(初始化语句; 条件表达式; 控制体语句){
for(初始化语句; 条件表达式; 控制体语句){
循环体语句…
}
}
举例(打印55的形列表)
class Demo7{
public static void main(String[] args){
for(int x=0; x<5; x++){
for(int y=0; y<5; y++){
System.out.print("*")
}
//换行
System.out,println();
}
}
}
6.跳转控制语句
1)break
结束,中断,不能单独使用! 一般在循环语句(loop),或者swith中用,不能超过这个范围;
2)continue
结束当前循环,立即进入下一次循环!(不能单独使用,在循环中使用)
应用 通过javaSE网络编程,多线程,集合,io流—网络聊天室 功能: 上下提醒 将全部用户—存储到"集合容器"中 遍历(for循环—获取数据)所有用户,如果当前用户名不是自己,可以使用continue,提示"其他用户上线了"
3)return
在Java中跟定义方法相关的,跟有返回值类型的方法有关 它结束有返回值类型的方法去使用的,一般很少单独用(可以用,不建议)
7.什么是java的方法
举例 植物大战僵尸—每一个关卡都有一个豌豆芽发射炮弹,发射炮弹需要写100行代码,才能完成逻辑!在每一个关卡中都需要写豌豆芽发射炮弹的这一百行代码
代码的冗余度非常大!需要优化,我们给这100行代码
使用{}包裹起来,给它起一个名字(方法名),以后其他关卡中,直接调用方法名就可以,提高了代码的复用!
方法就是通过独立的{}代码块,完成具体的逻辑,给它相应的名字!
(满足标识符的规则:变量和方法名需要满足小驼峰命名法)
1)定义格式
定义方法:(心中两个明确)
1)明确返回值类型
2)明确参数类型以及参数个数
①方式一
有返回值类型的方法定义(在需求中需要根据实际情景需要返回值类型:数据类型)
权限修饰符 static 返回值类型 方法名(参数类型1 参数类型2…){
完成方法的逻辑操作
return 结果;
}
解释:
权限修饰符:目前public公开的,访问权限足够大
static:键字可以用在变量、方法、代码块和嵌套类
方法名:满足小驼峰命名法
参数类型:就是数据类型(基本数据类型,引用数据类型)
return关键字:这个方法结束,带回结果,谁调用给谁!
注意事项:
1)方法和方法是平级关系,不能在一个方法中定义另一个方法;
2)定义方法的时候,返回值类型需要最终和return语句的结果类型一致,否则报错!
3)有左{ 大括号的地方不能有分号,有分号的地方不能出现"{"
4)定义方法的时候,形式参数类型必须带上,
5)调用方法的时候,实际参数要么定义要么键盘录入的,不需要在调用方法里面再去书写数据类型了
有返回值的调用
1)单独调用
2)输出调用
3)赋值调用
举例(调用求和方法)
public class Demo{
public static void main(String[] args){
//调用求和方法
int a=10;
int b=20;
//单独调用,没有输出结果;
//add(a,b); 传入实参
//输出调用,不推荐,写死了,下次用不了
//有返回值调用,建议
int result=add(a,b);
System.out.println(result);
}
public static void add(int x,int y){ //形参赋值,10给了x,20给了y
int z=x+y;
return z; //返回结果
}
}
②方式二
没有具体返回值类型的方法定义
格式
public static 返回值类型 方法名(形式参数类型1 参数名1,…){
逻辑操作
没有return返回值
System.out.println(“xxx”);
}
在一些具体的业务场景中,像数组排序,99乘法表,猜数字游戏(提示"大了,小了,还是猜中了…"),没有具体的返回结果
但是还要遵循方法定义格式,所以Java提 供了关键字void 充当这个 (返回值类型 ),只是没有具体返回结果的一种格式而已!
调用:只能用单独调用
举例(打印55的形)
public class FunctionDemo3 {
public static void main(String[] args)
//单独调用
printxing(6);
}
/**
* 定义一个方法:
* 打印*形
* 明确返回值类型: 没有具体结果,最终是在这个方法完成完成打印*,void 代替
* 明确参数类型以及参数个数
* int类型,2个参数
*/
public static void printStar(int x,int y){//x,行数,y,列数
for(int i = 0 ; i <x ; i ++ ){//行数
for(int j = 0 ; j < y ; j ++){//列数
System.out.print("*");
}
System.out.println();
}
}
}
2)方法重载OverLoad(重点)
为了标记同一种方法里面可以完成不同参数的使用,为了提高代码的扩展!
java提供overload方法重载
多个方法名可以相同,参数列表不同,与返回值无关!
1)参数类型不同
2)参数个数不同
3)考虑参数的先后顺序不同
方法重载的目的:
为了提供这个方法的扩展性,同一个方法可以传递不同的类型,完成具体逻辑操作;
jdk提供很多工具类都是有方法重载,Math类提供 方法abs(int/long/float/double):求绝对值
8.jvm内存分配:栈,堆,本地方法区(系统相关),寄存器(系统相关)
9.引入一个容器—数组(重点一维数组)
数组是一个容器,这个容器能够存储同一种类型的多个元素!
定义
数据类型[ ] 数组名称 ;
举例
int[ ] arr;
创建数组
两种方式
1)动态初始化
数据类型[ ] 数组名称= new 数据类型[数组长度];
举例
int[ ] arr = new int[3];
2)静态初始化
格式
数据类型[] 数组名称 =new 数据类型[]{元素1,元素2…};
简写格式
数据类型[] 数组名称={元素1,元素2…};
举例
int[ ] arr={1,2,3};
注意事项:
不能动静结合!
11.创建一个数组以及两个数组对象/多个数组对象内存分配(理解)
创建一个对象内存图解
创建两个对象内存图解
创建多个对象内存图解
创建数组静态初始化过程
12.数组的应用
1)数组元素查表法
就是通过数组名称{索引值}访问元素
举例(键盘录入星期1-7,通过索引值来访问)
public class ArrayTest3 {
public static void main(String[] args) {
//创建一个字符串数组----类似数据表
String[] strArray = {"星期一","星期二","星期三","星期四","星期五","星期六","星期日"} ;
//创建键盘录入对象
Scanner sc = new Scanner(System.in) ;
//提示并录入数据
System.out.println("请输入一个数据n(1-7):");
int n = sc.nextInt();
switch (n){
case 1 :
System.out.println(strArray[0]);
break ;
case 2 :
System.out.println(strArray[1]);
break ;
case 3 :
System.out.println(strArray[2]);
break ;
case 4 :
System.out.println(strArray[3]);
break ;
case 5 :
System.out.println(strArray[4]);
break ;
case 6 :
System.out.println(strArray[5]);
break ;
case 7 :
System.out.println(strArray[6]);
break ;
default:
System.out.println("对不起,输入数据不合法!");
break ;
}
}
}
2)数组中基本元素查找
特点:数组无序或者有序都可以,从头查到尾部,如果查不到,返回负数(找不到,-1)
后面将高级查找 (二分搜索法,也称为"折半查找":前提条件,数组必须有序!) jdk工具类---Arrays--->binarySearch(int[] arr,int target)--->获取元素第一次出现索引值
举例(找出元素第一次出现的索引值)
public static int getIndex(int[] array,int target){//array:指定的数组中查询,target:找的元素
//1)直接遍历数组
for(int i = 0 ; i < array.length; i ++){
//2)一一获取到数组元素,如果这个target就是跟array[i]一致,说明target就是我们要找的元素
if(target == array[i]){
//返回角标值即可;
return i ;
}
}
//如果找了一圈,for结束了,还找不到,返回-1
return -1 ;
}
3)数组最值问题
13.数组高级用法—冒泡排序
冒泡排序思想 两两比较,将较大的值往后放,第一次比较完毕,最大值就出现在最大索引处
依次这样比较,可以得到一个排好序的数组;
规律:
1)两两比较,较大的值往后放
2)第一次有0个不比,
第二次有1个不比
第三次有2个不比
…
比较的次数:数组长度-1次
14.面向对象的思想特点是什么?面向对象和面向过程有什么区别?(理论)
格式
类名 对象名 = new 类名() ;
对象名.成员变量名 = 值 (根据成员变量的类型赋值); 访问成员变量 赋值
对象名.方法名(); 访问我们自己的定义的成员方法,去使用它,展示数据或者实现具体业务需求
在一个类中引用另一个类需要创建类对象
举例
//定义手机类
public class Phone {
//成员变量--->跟类的对象有关系 new出来的
String brand ; //品牌
int price ; //价格
String color ; //颜色
String memory ;//机身内存
//成员方法
public void call(String toName){
System.out.println("使用"+brand+"这个手机"+"给"+toName+"打电话") ;
}
//发短信
public void sendMesage(){
System.out.println("使用"+brand+"手机发短信了");
}
//玩游戏
public String playGame(String gameName){
return "使用"+brand+"手机,可以玩"+gameName;
}
}
思想特点
1)更符合现实生活中的思想行为习惯
2)让复杂的事情简单化
3)角色发生了改变:从执行者(面向过程)—>变成指挥者(面向对象)
举例生活中例子
买电脑
面向过程:亲力亲为
看配置(自己中意的)—>去赛格电脑城货比三家—>砍价---->买了电脑
—>发现被坑了
面向过程:找一个懂行的人帮助我干这件事情(对于这个人—>面向过程)
看配置(自己中意的)---->找一个懂行的人---->买回来电脑
15.面向对象设计理念以及面向对象三个特征(记忆)
面向对象的设计理念:
不断的创建对象,使用对象,指挥对象做事情!(面对对象的宗旨)
一直用的Scanner:键盘录入
Scanner sc = new Scanner(System.in) ;
//sc.nextInt() ; sc.nextLine();
sc.nextBoolean();
面向对象的三大特征:封装,继承,多态(面向对象重点)
16.什么是类?
1)类的概念
clss Student{}
--- 成员变量---类中方法外, name,age,gender
--- 成员方法--- study()
如何将现实生活中的真实存在的事物---->我们的代码(以Java编程方式写出来进行测试)
事物 学生事物
— 属性 姓名,年龄,性别
— 行为 学习
对象是什么---------->体现出来的现实生活着具体的事物
java代码中体现一个具体的事物(使用对象来描述)
类名 对象名= new 类名() ; 创建一个对象(描述现实生活中具体事物)
学生事物(概括性的)–>张三,20,男 李四 25,女
2)创建一个类
3)创建两个类
4)创建多个类
17.形式参数: 基本数据类型和引用类型 —调用该方法,实际参数?
基本类型:传什么类型,实际参数给对应类型的值;
重点: 引用类型 ----- 如果形式参数是具体类型----->实际参数如何传递?
18.匿名对象(没有名字的对象) (重点)
描述具体事物—java代码 体现
类名 对象名 = new 类名() ;
new 类名().成员变量=赋值;
new 类名().成员方法 ;
19.关于封装的概念 (重点)
private :私有的 ,修饰的成员变量或者成员方法只能本类中访问 (为了保证数据安全)
20.this关键字 (重点)
this的含义: 代表当前类对象的地址值引用
加入this---->标准类的写法 (描述学生事物/描述手机事物)
JavaBean规范:
1)类是具体类 class 类名{}
2)类的属性必须私有化
3)类中必须提供setXXX()/getXXX() 对成员变量的公共的访问方法(赋值/获取值)
面试题
Switch语句后面着个变量可以是什么样的数据类型?
本身能够跟的基本数据类型:byte,short,char,int Jdk5以后可以是枚举(引用类型) enum
JDK7以后可以跟String类型
switch语句中的注意事项:
1)case语句的后面只能是常量(在Java语言中:强类型语言:语法结构很严谨)
而前端javascript里面的switch语句的case可以是常量,变量;
2)在case语句里面,如果一旦匹配成功,一定书写break;否则会造成case穿透,case匹配成功了,就会执行里面的语句,遇见break语句结束;
3)switch中的default语句可以在语句中的任何位置,不影响语句的执行流程 正常的格式,在语句末尾,break可以是省略的;
如果在语句中,break带上,否则case穿透了 (考点) 4)switch语句的结束条件: 第一种情况,就是语句break结束;
case语句后面的break或者default语句的break
第二种情况,就是语句默认执行到末尾结束!
for和while循环有什么区别?
1)从用法格式上看,格式不同,while循环的这个格式,不要忽略了控制体语句; 2)是否明确循环次数(开发中,优先使用for)
如果需求明确了循环次数,优先使用for循环,工程上的for循环使用最多的! 如果不明确循环次数,使用while循环(猜数字游戏)
3)从内存角度考虑,for循环更优一些,比较节省内存空间
从for循环本身的格式上来说,for循环结束,里面的局部变量(方法定义中的变量)就被及时的释放空间!
while循环格式,结束之后,依然能够去访问那个变量,(比较消耗内存空间) 所以相对来说whle循环没有for循环好
局部变量和成员变量有什么区别
- 书写位置不同
局部变量:在方法定义中或者方法声明上的变量
-
成员变量:类中方法外!
-
实际开发中:根据具体的情况具体使用,范围越小越好,因为范围小,使用完,释放内存了!
2)内存位置不同
-
局部变量:在栈内存中---跟方法有关(方法进栈)
-
成员变量:在堆内存中---跟对象有关 (类名 对象名 = new 类名();)
3)生命周期不同:
-
局部变量:随着方法调用而存在,随着方法调用结束而消失
-
成员变量:随着对象的创建而存在,随着对象的创建完毕后,使用完毕(访问成员变量/访问成员方法)之后等待
- 初始化值不同
局部变量:在使用之前必须初始化,否则报错
-
成员变量:跟对象有关系,存在系统默认初始化,然后可以显示初始化 对象名.成员变量名=赋值;
引用类型_数组作为形式参数
数据结构与算法
1.求和思想(阶乘)
class DemoSum{
public static void main(String[] args){
//求和
int sum;
for(int i=0; i<=10; i++){
sum+ = i;
}
System.out.println(sum);
//阶乘
int jc=1;
for(int x=0; x<=10; x++){
jc*=x;
}
System.out.println(jc);
}
}
2.水仙花(各位数立方之和=数据本身)
class DemoSxh{
public static void main(String[] args){
int count=0;
for(int x=100; x<1000; x++){
int ge=x%10;
int shi=x/10%10;
int wan=x/100%10;
if(x==ge*ge*ge+wan*wan*wan+shi*shi*shi){
//统计变量
count ++;
System.out.println(x);
}
}
System.out.println("水仙花有"+count);
}
}
3.猜数字游戏
import java.until.Scanner;
class DemoCsz{
public static void main(String[] args){
//产生一个double随机数(0.0-1.0) 通过Math.random()
//强转,∵0取 ∴+1
int num=(int)(Math.random()*100+1)
//定义统计变量
int count=0;
while(ture){ //死循环
count++; //统计变量
Scanner sc=new Scanner(System.in);
System.out.println("请输入猜的数:")
int a=sc.nextInt();
if(a<0||a>100){
System.out.println("输入不合法");
break;
}else if(a>num){
System.out.println("输入的数大了");
}else if(a<num){
System.out.println("输入的数小了");
}else{
System.out.println("您是第"+count"次猜中的")
break;
}
}
}
}
Math.random 生成0.1-1.0的随机数
4.打印nn乘法表
import java.until.Scanner;
class Democfb{
public static void main(String[] args){
Scanner sc=new Scanner(System.in);
System.out,println("请输入一个数:")
int n-sc.nextInt();
for(int x=1; x<=n; x++){
for(int y=1; y<=x; y++){
System.out.print(x+"*"+y+"="+(y*x)+\t);//\t 制表符
}
System.out,println();//换行
}
}
}
5.冒泡排序
public static void bubbleSort(int[] arr){
for(int x = 0 ; x < arr.length-1;x++){//控制比较的次数
// arr.length-1-x:为了减少比较的次数
for(int y = 0 ; y < arr.length-1-x; y++){
//如果前面的元素比后面元素大
if(arr[y]> arr[y+1]){
int temp = arr[y] ;
arr[y] = arr[y+1] ;
arr[y+1] = temp;
}
}
}
}
6.穷举算法(百钱买百鸡)
public class Test1 {
public static void main(String[] args) {
//百钱买百鸡
System.out.println("购买的方案是:");
for(int x = 0 ; x <=20 ;x++){//x代表公鸡数量,公鸡5文钱一只,最多可以买20只
for(int y = 0 ; y<=33; y++){ //y代表母鸡数量,母鸡3文钱一只,最多可以买33只
//得到小鸡的数量z,100数量-母鸡和公鸡的数量
int z = 100 - x - y ;
//满足条件
//100=5*x+3*y+z/3 并且同时小鸡的个数能够被3整除(小鸡是一文钱三只)
if(100==(5*x+3*y+z/3) && (z%3==0)){
System.out.println("公鸡的数量是:"+x+",母鸡的数量是:"+y+",小鸡数量是:"+z);
}
}
}
}
}