java第三周笔记

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循环好

局部变量和成员变量有什么区别

  1. 书写位置不同
    局部变量:在方法定义中或者方法声明上的变量
  •      成员变量:类中方法外!
    
  •      实际开发中:根据具体的情况具体使用,范围越小越好,因为范围小,使用完,释放内存了!
    

2)内存位置不同

  •       局部变量:在栈内存中---跟方法有关(方法进栈)
    
  •       成员变量:在堆内存中---跟对象有关  (类名 对象名 = new 类名();)
    

3)生命周期不同:

  •        局部变量:随着方法调用而存在,随着方法调用结束而消失
    
  •        成员变量:随着对象的创建而存在,随着对象的创建完毕后,使用完毕(访问成员变量/访问成员方法)之后等待
    
  1. 初始化值不同
    局部变量:在使用之前必须初始化,否则报错
  •        成员变量:跟对象有关系,存在系统默认初始化,然后可以显示初始化 对象名.成员变量名=赋值;
    
  • 在这里插入图片描述

引用类型_数组作为形式参数

在这里插入图片描述

数据结构与算法

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

        }
    }
}
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值