第三周总结(2022.10.31~2022.11.4)-CSDN博客

面试题:
           if...else...和三元运算符的区别?
       共同点:
           都是针对两种情况进行判断,都有表达式;
       不同点:
           if...else...流程控制语句,范围很大,不仅仅可以操作数据值,还可以
       操作输出语句去完成逻辑判断;而三元运算符仅仅是运算符,操作两个具体的数据值;

       三元运算符能实现的一定能够使用if...else...流程语句
       if....else....流程语句实现的,不一定能够使用三元!
       (流程控制语句操作 System.out.println())

2.if...else...嵌套

使用键盘录入数据,录入三个数据,求三个数据中的最大值?
   if....else....一种嵌套 (不推荐,知道可以实现解决一些问题)
   if(表达式1){
       if(表达式2){
           语句1;
       }else{
           语句2;
       }
   }else{
       if(表达式3){
           语句3;
       }else{
           语句4;
       }
   }

import java.util.Scanner ;
class IfTest{
	public static void main(String[] args){
		
		//创建键盘录入对象
		Scanner sc = new Scanner(System.in) ;
		
		//提示并录入数据
		System.out.println("请输入第一个数据:") ;
		int a = sc.nextInt() ;
		
		System.out.println("请输入第二个数据:") ;
		int b = sc.nextInt() ;
		
		System.out.println("请输入第三个数据:") ;
		int c = sc.nextInt() ;

		//if...else...嵌套实现

		//Java中尽量采取赋值的方式,而不是全部都直接输出,
		//最终逻辑写完了,在if语句的外面输出结果变量

		int max3;
		if(a>b){
			//a>b,成立
			//继续判断a和c
			if(a>c){
				max3 = a ;
			}else{
				max3 = c ;
			}
			
		}else{
			//a<b,
			//使用b和c比较
			if(b>c){
				max3 = b ;
			}else{
				max3 = c ;
			}
		}
		System.out.println("三个数据中的最大值:"+max3) ;
	}
}

3.流程控制语句之switch(考点很多)

3.1什么是switch语句?

选择结构之switch
   switch(变量名){
   case 值1:
       语句1;
       break ;
   case 值2;
       语句2;
       break ;
   ....
   ....
   ....
   default:
       语句n;
       break ;
   }
   执行流程:
           switch后面的变量需要和case进行匹配,case 值1:成立,执行语句1,
遇见break,switch语句结束;
           如果不匹配,继续执行case 值2:成立,执行语句2,break结束


	public static void main(String[] args){
		//创建键盘录入对象
		Scanner sc =  new Scanner(System.in) ;
		
		//提示并录入数据
		System.out.println("请输入一个星期值(1-7):") ;
		int weekNum = sc.nextInt() ;
		
		switch(weekNum){
		
		case 1:
				System.out.println("星期一") ;
				break ;
		case 2:
				System.out.println("星期二") ;
				break ;
		case 3:
				System.out.println("星期三") ;
				break ;
		case 4:
				System.out.println("星期四") ;
				break ;
		case 5:
				System.out.println("星期五") ;
				break ;
		case 6:
				System.out.println("星期六") ;
				break ;		
		case 7:
				System.out.println("星期日") ;
				break ;	
				
		default:	
			System.out.println("对不起,您录入的数据不合法") ;
			break ;
		}
		
	}
}

3.2switch语句中的注意事项

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
           第二种情况,就是语句默认执行到末尾结束!

3.3switch语句中case穿透的灵活运用

import java.util.Scanner ;
class SwitchTest2{
	
	public static void main(String[] args){
		
		//创建键盘录入对象
		Scanner sc = new Scanner(System.in) ;
		
		//提示并录入数据
		System.out.println("请输入一个月份的值:") ;
		int month = sc.nextInt() ;

		switch(month){
		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 1:
		case 2:
		case 12:
			System.out.println("冬季") ;
			break ;
		default:
			System.out.println("对不起,地球没有该月份!") ;
			break ;	
		}
	}
}

4.循环结构语句(重点去会使用)

4.1循环结构语句之while循环

while循环的格式:

初始化语句;
   while(条件表达式){
       循环体语句;
       控制体语句;
   }
   执行流程:
       1)初始化语句进行变量赋值,执行一次;
       2)判断条件表达式是否成立,成立,执行循环体语句,依次执行控制体语句;
       3)再次回到2)继续操作
       ...
       ...
       当条件表达式不成立,while循环结束

class WhileDemo{
	public static void main(String[] args){
		/*
			初始化语句;
	while(条件表达式){
		循环体语句;
		控制体语句;
	}
		*/
		
		int i = 1 ;
		while(i<=5){
			System.out.println("我爱hm") ;
			i++ ;
		}
	}
}

4.2循环结构语句之for循环

循环结构语句:
       当需求中有这种循环的思想,就需要使用循环语句去实现
       for循环格式

           for(初始化语句;条件表达式;控制体语句){

                   //实际开发中,此处需要去完成一些逻辑判断
                   循环体语句;
           }

   执行流程:
       1)初始化语句,对变量进行赋值,
       2)条件表达式判断结果是否成立,成立,则执行循环体语句,进行控制体语句++或者--
       3)继续判断条件表达式是否成立,成立,继续上面这种操作...
       ...
       ...
       如果控制体语句造成了条件表达式不成立,语句结束!

class Demo{
	public static void main(String[] args){
		
		//for(初始化语句;条件表达式;控制体语句){
					//循环体语句;
			//}
			
		for(int x = 1 ; x <=10;x++){//x=1,1<=10,x++,2<=10,继续循环体
			//循环体语句;

			System.out.println("helloworld") ; 
		}	
	}
}

4.3while循环与for循环的区别

面试题:
       for和while循环有什么区别?

       1)从用法格式上看,格式不同,while循环的这个格式,不要忽略了控制体语句;
           for(初始化语句;条件表达式;控制体语句){
               循环体语句;
           }
           初始化语句;
           while(条件表达式){
               循环体语句;
               控制体语句;
           }
       2)是否明确循环次数(开发中,优先使用for)
           如果需求明确了循环次数,优先使用for循环,工程上的for循环使用最多的!
           (最频繁的)
           如果不明确循环次数,使用while循环举例: 猜数字游戏(1-100的数据)
                                                       统计才多少次(使用while新年好)
                                               不断录入数据,模拟用户登录
                                                       密码和用户名的信息都不一致,错误
                                                       否则,登录成功...
       3)从内存角度考虑,for循环更优一些,比较节省内存空间
           从for循环本身的格式上来说,for循环结束,里面的局部变量(方法定义中的变量)
           就被及时的释放空间!

           while循环格式,结束之后,依然能够去访问那个变量,(比较消耗内存空间)
           所以相对来说whle循环没有for循环好

4.4循环结构语句之dowhile循环

do-while循环的格式

   初始化语句;
   do{
       循环体语句;
       控制体语句;
   }while(条件表达式) ;

   初始化语句赋值
   判断条件,成立,执行循环体,控制体语句,再次判断....

特点:
            和for,while最大的区别就是:即使条件不成立,循环体至少执行一次!
           开发中 do-while很少,一般也就是jdk提供的类的源码中会见到!

4.5两种死循环格式

两种死循环格式:
           for( ; ; ){
               循环体语句;
           }
while(true){       //推荐这个格式
               循环体语句;
           }

        死循环的格式最终里面完成某个逻辑,当达到某种条件结束循环
        会用到一个跳转控制语句 break(中断,结束) ;
        不能单独用,它使用在循环语句以及switch语句中;

5.for循环嵌套

5.1什么是for循环嵌套

for循环的嵌套
       for循环的循环体语句里面是for循环

       for(初始化语句1;条件表达式1;控制体语句1){

           for(初始化语句2;条件表达式2;控制体语句2){
               循环体语句.....
           }
       }

5.2for循环嵌套的使用

需求:
输出四行5列的*形
*****
*****
*****
*****

class ForForDemo{
	public static void main(String[] args){
		//原始的做法:
		System.out.println("*****") ;
		System.out.println("*****") ;
		System.out.println("*****") ;
		System.out.println("*****") ;
		//不好,上面的代码,冗余度太大(重复度太大)
		System.out.println("---------------------------------------") ;
		//循环思想改进
		for(int x = 0 ; x < 4 ; x ++){//0,1,2,3
			System.out.println("*****") ;
		}
		
		System.out.println("---------------------------------------") ;
		
		//上面虽然可以,使用for循环,但是*,单独去输出 冗余度在低一些
		//一行5个*,我可以将一行的每一个*都使用for循环操作
		//每一个*在同一行上,将输出语句System.out.print() ,在同一行上打印
		//第一行的5个*
		for(int x = 0 ;x < 5 ;x++){ //0,1,2,3,4
			System.out.print("*") ;
		}
		//换行
		System.out.println() ;
		
		System.out.println("--------------第二行----------------") ;
		//第二行 还是5个*
		for(int x = 0 ;x < 5 ;x++){ //0,1,2,3,4
			System.out.print("*") ;
		}
		//换行
		System.out.println() ;
		
		System.out.println("--------------第三行----------------") ;
		//第三行 还是5个*
		for(int x = 0 ;x < 5 ;x++){ //0,1,2,3,4
			System.out.print("*") ;
		}
		//换行
		System.out.println() ;
		System.out.println("--------------第四行----------------") ;
		//第四行 还是5个*
		for(int x = 0 ;x < 5 ;x++){ //0,1,2,3,4
			System.out.print("*") ;
		}
		//换行
		System.out.println() ;
		
		System.out.println("-------将上面代码最终优化为:---------") ;
		
		//上面代码也能够实现,冗余度还是存在,为了更好的去书写
		//使用for循环嵌套,上面的代码循环四次
		for(int x = 0 ; x < 4 ; x ++){//行数,四行,x= 0 ,1,2,3
			for(int y = 0 ;y < 5 ;y++){ //列数,5列 y=0,1,2,3,4 
				System.out.print("*") ;
			}
			//换行
			System.out.println() ;
		}
	}
}

Day2

1.跳转控制语句

1.1跳转控制语句之break;

break:结束,中断,不能单独使用!
   一般在循环语句(loop),或者是switch语句中用,不能超过这个范围去使用;

   for循环嵌套中也可以使用break

   break 标签名称; 在多层循环嵌套的时候,标签名称就是给循环语句前面加上的标签名字(以前的早期用法)
   xx:for(初始化语句;条件表达式;控制体语句){
   xx:for(初始化语句;条件表达式;控制体语句){
   }
   }

1.2跳转控制语句之continue;

跳转控制语句
   continue 结束当前循环,立即进入下一次循环! (不能单独用,在循环中用)
   应用:
   通过JavaSE网络编程,多线程,集合,io流---网络聊天室

1.3跳转控制语句之return

return:    是在Java中跟定义方法相关的,跟有返回值类型的方法有关
            它结束有返回值类型的方法去使用的,一般很少单独用(可以用,不建议)
            return实际开发中,和方法息息相关

2.Java中的方法

2.1什么是Java中的方法

什么是Java中的方法?
例如:植物大战僵尸,每一个关卡都有一个豌豆芽发射炮弹,发射炮弹需要写100行代码,才能完成逻辑!在每一个关卡中都需要写豌豆芽发射炮弹的这一百行代码代码的冗余度非常大!需要优化,我们给这100行代码使用{}包裹起来,给它起一个名字(方法名), 以后其他关卡中,直接调用方法名就可以,提高了代码的复用!

方法就是通过独立的{ }代码块,完成具体的逻辑,给它相应的名字!
(满足标识符的规则:变量和方法名需要满足小驼峰命名法)

2.2Java中定义的方法格式?(两种格式)

格式一

有返回值类型的方法定义(在需求中需要根据实际场景需要返回值类型:数据类型)
   权限修饰符 static 返回值类型方法名(参数类型1 参数名称1,参数类型2 参数名2....)

                {
   //完成的方法逻辑操作
   return 结果;
   }

-------------------------------------------------------------------------------------------------------------------------

解释:
        权限修饰符 :目前 public 公共,公开的,访问权限足够大
static: 这周面向对象中讲 (必须先上)
返回值类型:现在数据类型(这几天:使用的基本数据类型,以后就是引用类型)
方法名:满足标识符的规则-->方法名需要满足"小驼峰命名法")
参数类型:就是数据类型(这几天:使用的基本数据类型,以后就是引用类型)
参数名称:就是形式参数(变量名)
  return:关键字 :这个方法结束,带回结果,谁调用,给谁! (返回结果--->最终后期交给前

        端(JavaEE技术))

-------------------------------------------------------------------------------------------------------------------------

有具体返回值的方法的调用
   1)单独调用        2)输出调用        3)赋值调用

格式二

没有具体返回值类型的方法定义

正常的格式:
   public static 返回值类型方法名(形式参数类型1 参数名1,.....){
   里面直接完成了输出操作或者一些其他逻辑,
   没有return关键字
   System.out.println("xxxx") ;
   }

-------------------------------------------------------------------------------------------------------------------------

在一些具体的业务场景中,像数组排序,99乘法表,猜数字游戏(提示"大了,小了,还是猜中了..."),没有具体的返回结果
   但是还要遵循方法定义格式,所以Java提供了关键字void 充当这个 (返回值类型 ),只是没有具体返回结果的一种格式而已!

没有具体返回结果的方法的定义格式 (回想:我们的main这样写的)
   public static void 方法名(形式参数类型1 参数名1,.....){
   里面直接完成了输出操作或者一些其他逻辑,
   没有return关键字
   System.out.println("xxxx") ;
}

-------------------------------------------------------------------------------------------------------------------------

调用:
1)单独调用(只能用这个)

2.3定义方法的注意事项

1)方法和方法是平级关系,不能在一个方法中去定义另一个方法!
2)定义方法的时候,返回值类型需要最终和return语句的结果类型一致,否则报错!
3)有左{ 大括号的地方不能有分号,有分号的地方不能出现"{".
4)定义方法的时候,形式参数类型必须带上,Java语言强类型语言(语法结构很严谨,不像Javascript,定义函数的时候,不需要写参数类型).
5)调用方法的时候,实际参数要么定义要么键盘录入的,不需要在调用方法里面再去书写数据类型了.

2.4方法的重载

为了标记同一种方法里面可以完成不同参数的使用,为了提高代码的扩展!
   java提供overload方法重载

   多个方法的方法名可以相同,参数列表不同,与返回值无关!
   参数列表不同:可以有下面几种
   1) 参数类型不同
   2)参数个数不同
   3)考虑参数的先后顺序不同

Day3

什么是数组?

数组是一个容器,这个容器能够存储同一种类型的多个元素!
   举例:
   比如有80个员工发工资,每一个员工就是变量,我是不是定义80个变量,分别记录员工工资;
  在计算机语言中,这种不合适,定义80个变量!(在真实的工资系统中,它会设计让你拿变量去操作??)
  如果有一个"容器",能够将80个变量放进去,这样操作更加简单!

   随着不断学习,"容器"--->数组--->StringBuffer:字符串缓冲区---->集合---->IO流存储到文件中----->数据库!

如何定义一个数组?

Java规定有一种固定的格式
   数据类型[] 数组名称 ;
   数据类型数组名称[] ;
   //举例:int[] arr; 定义一个int类型对数组arr变量
   int arr[] ; 定义一个int类型arr数组

   创建数组---->对数组进行初始化(创建数组对象)----两种方式
   1)动态初始化
   2)静态初始化

   1)动态初始化:程序员你自己给定数组长度,系统去默认分配的元素值
   数据类型[] 数组名称 = new 数据类型[数组长度];
   或者数据类型数组名称[] = new 数据类型[数组长度] ;

创建数组的静态初始化的格式

指定数组的元素,长度由系统给定
  本身的格式
   数据类型[] 数组名称 = new 数据类型[]{元素1,元素2,元素3...}; 推荐这个
   或者
   数据类型数组名称[] = new 数据类型[]{元素1,元素2,元素3...};

   简写格式
   数据类型[] 数组名称 = {元素1,元素2,元素3...};
   或者
   数据类型数组名称[] = {元素1,元素2,元素3...};

   举例
   int[] arr = new int[]{1,2,3} ;---->int[] arr = {1,2,3} ;
   int arr2[] = new int[]{11,22,33} ;--->int arr2[] = {11,22,33} ;

   使用静态初始化
   不能动静结合!
   int[] arr = new int[3]{1,2,3} ; 错误的

引入异常---慢慢总结

人生病了--->得看病
  程序成出问题了 (异常!)--->得改bug!(改错)
   jdk提供了类 java.lang.Throwable-->Exception/error (后期讲常用类的去讲)

   Exception类
   子类 RuntimeException:运行时期异常 (程序在运行时发生的问题--->代码写的逻辑不严谨或者一些漏洞)
   不是RuntimeException里面的类:都是编译时期异常(在idea或者eclipse开发工具中,编译通过不了,语法错误!)
   error:严重问题(错误) ---内存溢出

   以后见到异常---->总结出来一套东西
   总结:什么原因导致的这个异常?
   这个异常的解决方案?
   这就是经验!

   数组里面或者以后学到String类都会出现一种"角标越界"
   String--字符串 "helloworld" ---底层就是'h','e','l','l'....这些字符组成的(char[])

   java.lang.ArrayIndexOutOfBoundsException:数组角标越界异常(属于运行时期异常!)
   出现的原因:访问了数组中不存在的索引值
   解决方案:检查代码,控制索引值!

   java.lang.NullPointerException:空指针异常 (伴随你的整个生涯)

   出现的原因:程序员在书写代码的时候,由于调用各种格样第三方提供这些功能,
   可能获取到某个对象为空值,然后还是用空对象去访问元素或者调用功能,都会出现这个问题!
   解决方案:最直接的方案:就是非空判断一下

   如果异常总结多了,那么经验丰富了!(提高排错能力)

冒泡排序

冒泡排序的思想:
   两两比较,将较大的值往后放,第一次比较完毕,最大值就出现在最大索引处
   依次这样比较,可以得到一个排好序的数组;
   规律:
   1)两两比较,较大的值往后放
   2)第一次有0个不比,
   第二次有1个不比
   第三次有2个不比
   ...
   比较的次数:数组长度-1次

public class ArrayTest {
    public static void main(String[] args) {
        //已知数组,静态初始化
        int[] arr = {24,69,87,56,13} ;
        System.out.println("排序前原始数组是:");
        //调用数组的遍历方法---将数组 [元素1, 元素2, 元素3,.... 元素n] 输出,展示
        printArray(arr);
        System.out.println("-----------------------------------") ;

        //第一次比较:
        //arr.length-1:为了防止角标越界
        //arr.length-1-0:第一次比较,有0个不比(都得比较)
        /*
        for(int x=0 ; x < arr.length-1-0 ; x ++){
            //核心代码
            //如果前的元素比后面的元素大,将前面的元素( 大的值)往后放
            if(arr[x]> arr[x+1]){//arr[0]  arr[0+1]
                //中间变量的方式
                int temp = arr[x] ;
                arr[x] = arr[x+1] ;
                arr[x+1] = temp ;
            }
        }
        System.out.println("第一次比较完毕后: ");
        //调用遍历的方法:展示数组元素
        printArray(arr);

        System.out.println("---------------------------------------") ;
        //第二次比较
        //arr.length-1:防止角标越界
        //arr.length-1-1: 第二次比较有1个不比
        for(int x = 0 ; x < arr.length-1-1;x++){
                if(arr[x] > arr[x+1]){
                    int temp = arr[x] ;
                    arr[x] = arr[x+1] ;
                    arr[x+1] = temp;
                }
        }
        System.out.println("第二次比较完毕后:");
        printArray(arr);
        System.out.println("------------------------------------");
        //第三次比较
        //arr.length-1:防止角标越界
        //arr.length-1-2:第三次比较有2个不比
        for(int x = 0 ; x < arr.length-1-2;x++){
            if(arr[x] > arr[x+1]){
                int temp = arr[x] ;
                arr[x] = arr[x+1] ;
                arr[x+1] = temp;
            }
        }
        System.out.println("第三次比较完毕之后:");
        printArray(arr);

        System.out.println("----------------------------");
        //第四次比较
        //arr.length-1:防止角标越界
        //arr.length-1-3:第四次比较有3个不比
        for(int x = 0 ; x < arr.length-1-3;x++){
            if(arr[x] > arr[x+1]){
                int temp = arr[x] ;
                arr[x] = arr[x+1] ;
                arr[x+1] = temp;
            }
        }
        System.out.println("第四次比较完毕之后:");
        printArray(arr);

         */

        //将上面的重复性代码进行优化:冗余度太大
        //循环了四次
        /*for(int x = 0 ; x < 4;x++){//x=0,1,2,3      4是数的 (控制次数)
            //x=0,0<4,
            for(int y = 0 ;y < arr.length-1-x;y++){
                //arr[0] ; y< arr.length-1-0 :第一次有0 个不比
                if(arr[y] > arr[y+1]){  //arr[0]  arr[1]
                    int temp = arr[y] ;
                    arr[y] = arr[y+1] ;
                    arr[y+1] = temp;
                }
            }
        }
        System.out.println("排序之后:");
        //调用遍历
        printArray(arr);*/
        System.out.println("------------------------------------------");
        //上面的4的次数,数的,----优化----4-就是比较次数:数组长度-1次
        for(int x = 0 ; x < arr.length-1;x++){//x=0,1,2,3
            //x=0,0<4,
            //arr.length-1-x:就是为了减少比较的次数
            for(int y = 0 ;y < arr.length-1-x;y++){
                //arr[0] ; y< arr.length-1-0 :第一次有0 个不比
                if(arr[y] > arr[y+1]){  //arr[0]  arr[1]
                    int temp = arr[y] ;
                    arr[y] = arr[y+1] ;
                    arr[y+1] = temp;
                }
            }
        }
        System.out.println("排序之后:");
        //调用遍历
        printArray(arr);

        System.out.println("-------------最终版代码--------------");
        //使用方法来调用排序的代码--->只是排序的方法
        bubbleSort(arr);
        //在调用遍历功能,展示数据
        printArray(arr);

    }
    /*
    * 定义一个冒泡排序的方法:
    *   两个明确
    *       明确返回值类型: 没有具体返回值 --直接元素里面互换  void
    *       明确参数类型  以及参数个数
    *               指定数组,1个
    * */
    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;
                }
            }
        }
    }

    /**
     * 遍历数组的方法
     * @param arr 对已知的数组遍历
     */
    public static void printArray(int[] arr){
        System.out.print("[");
        //遍历数组
        for(int x = 0 ; x < arr.length ; x++){
            //判断:如果是最大索引值,取到最后一个元素
            if(x== arr.length-1){
                System.out.println(arr[x]+"]");
            }else{
                //中间的元素
                System.out.print(arr[x]+", ");
            }
        }
    }
}

Day4

1.白钱买百鸡(算法)

百钱买百鸡：公鸡5文钱一只，母鸡3文钱一只，小鸡1文钱3只，
  如何使用100文钱买到一百只鸡,公鸡,母鸡,小计各多少只?(牛客网)

  穷举算法:
   如果将100文钱都买公鸡,能买多少只最多20只
   100文钱都买买多少只? 最多33只
   100文钱都买小鸡 300只,在100文钱的前提下,需要使用循环操作,需要列出母鸡,公鸡,小鸡的数量

   定义三个变量,x,y,z都分别公鸡,母鸡,小鸡的数量
   列出公鸡的数量 0到20
   列出母鸡的数量 0 33只 --->考虑去使用for循环嵌套

   小鸡的数量 z=100-x-y;
   满足条件:小鸡的数量应该能3整除才能有效数据! 而且满足总数量 100只=x*5+y*3+z/3

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

        }
    }
}

2.面向对象的思想特点是什么?

1)更符合现实生活中的思想行为习惯

2)让复杂的事情简单化

3)角色发生了改变:从执行者(面向过程)--->变成指挥者(面向对象)

3.面向对象和面向过程什么区别?(理论)

面向过程:强调的是功能行为,以函数为最小单位,考虑怎么做.

面向对象:强调具备了功能的对象,以类/或对象为最小单位,考虑谁来做.

4.面向对象设计理念

不断的创建对象,使用对象,指挥对象做事情!(面对对象的宗旨)

一直用的Scanner:键盘录入

Scanner sc = new Scanner(System.in) ;

//sc.nextInt() ; sc.nextLine();

sc.nextBoolean();

5.面向对象的三大特征(记忆)

封装,继承,多态(面向对象重点)

6.什么是类(Java编程语言中)? ----->就是现实世界中的真实存在多事物

类的概念       clss Student{}
   --- 成员变量---类中方法外, name,age,gender
   --- 成员方法--- study()

如何将现实生活中的真实存在的事物---->我们的代码(以Java编程方式写出来进行测试)

事物       学生事物
   --- 属性   姓名,年龄,性别
   --- 行为学习

对象是什么---------->体现出来的现实生活着具体的事物
java代码中体现一个具体的事物(使用对象来描述)
类名对象名= new 类名() ; 创建一个对象(描述现实生活中具体事物)

学生事物(概括性的)-->张三,20,男李四 25,女

7.什么是对象?

对象:描述现实世界的具体事物!(具体事物的具体的属性和行为)
   现实世界的事物---是很概括性的;
   学生事物----->姓名,年龄,性别----是谁? 不知道,

需要描述具体的事物------> 具体学生张三 25 男 / 李四 20 女

在代码中体现出来具体事物----->需要记住Java中的创建类对象的格式
   类名对象名 = new 类名() ;
   对象名.成员变量名 = 值 (根据成员变量的类型赋值); 访问成员变量赋值
   对象名.方法名(); 访问我们自己的定义的成员方法,去使用它,展示数据或者实现具体业务需求

Day5

1. 形式参数: 基本数据类型和引用类型

形式参数是基本类型和引用类型,实际参数传递问题! (重点要就引用类型)

形式参数是基本类型,调用该方法,实际参数传递对应类型的数据值即可(简单,数据值传递)

形式参数是引用类型(如果是类),调用这个方法,实际参数传递需要传递当前类的具体对象 (创建类对象)

2.匿名对象(没有名字的对象) (重点)

匿名对象: 没有名字的对象!
  有名字的对象---描述具体事物 ---创建对象格式
  类名对象名 = new 类名() ;

  匿名对象格式:
   new 类名();

   特点:
   1)可以作为"参数传递"
   2)实际用的过程,匿名对象不要多次,一般使用一次即可,使用完毕立即被回收!

在android中匿名对象使用居多 (移动端内存小,节省内存)

3.关于封装的概念 (重点)

private关键字的特点
   可以修饰成员变量/成员方法,只能在当前类中访问,外界类不能直接访问;
   但是,可以间接的通过公共的方法访问

就是保证成员属性的数据安全性,让外界类不能直接操作,只能在本来中去访问加入private(属性私有化,对外隐藏了)
   对外必须提供公共的成员方法setXXX()/getXXX()来赋值,和获取值!
   实际开发中:只要描述一个事物属性:全部私有!

4.this关键字 (重点)

在标准类(属性私有化,对外提供公共访问setXXX(xx)/getXXX()),给成员变量赋值形式参数必须见名知意,
   局部变量和成员变量名称一致,局部变量会隐藏成员变量,导致成员变量无法赋值!Java提供了关键字"this"
   this:代表当前类对象的地址值引用
   this.变量名 : 访问的是本来的成员变量名