学习java的窍门：

• 多练
• 多想

语言基础第一天 笔记：

1. java开发环境：

   • 编译运行过程：

     • 编译期：.java源文件，经过编译，生成.class字节码文件
     • 运行期：JVM加载.class并运行.class(0和1)

   • 名词解释：

     • JVM：java虚拟机

       ​ 加载.class并运行.class

     • JRE：java运行环境

       ​ 除了包含JVM以外还包含了运行java程序所必须的环境

       ​ JRE = JVM+java系统类库(小零件)

     • JDK：java开发工具包

       ​ 除了包含JRE以外还包含了开发java程序所必须的命令工具

       ​ JDK = JRE+编译、运行等命令工具

2. IDEA：开发工具

   • JetBrains公司的，分为社区版(免费的)和终级版(收费的)

   • 开发步骤：

     • 新建Java项目/工程-------------------------小区

     • 新建Java包-----------------------------------楼+单元

     • 新建Java类-----------------------------------房子

       main中：System.out.println(“hello world”);

       代码如下：

       package day01; //声明包day01(楼+单元)
       public class HelloWorld { //声明类HelloWorld(房子)
           //主方法，为程序的入口(大门口)，程序的执行从main开始，main结束则程序结束
           public static void main(String[] args) {
               //输出hello world
               //1)严格区分大小写
               //2)所有符号必须是英文模式的
               //3)每句话必须以分号结尾
               System.out.println("hello world"); //双引号中的原样输出
               System.out.println("欢迎大家来到达内");
           }
       }
       

   • 注释：解释性文本(计算机不执行)

     • 单行注释：//
     • 多行注释：/* */--------------------明天用
     • 文档注释：/** */------------------API入门时讲

补充：明天会用到的英文单词，明天我说的时候得认识，能背下来最好

1.单词:
  1)int:整型
  2)long:长整型
  3)double:浮点型
  4)boolean:布尔型
  5)char:字符型
  6)true:真 
  7)false:假
  8)unicode：统一码、通用码、万国码
  9)age:年龄
  10)score:成绩
  11)demo:例子
  12)var:变量
  13)data:数据
  14)type:类型
2.换算:
  1G=1024M(兆)
  1M=1024KB(千字节)
  1KB=1024B(字节)
  1B=8bit(位)

语言基础第二天：

回顾：

1. java开发环境：

   • 编译运行过程：

     • 编译期：.java源文件，经过编译，生成.class字节码文件
     • 运行期：JVM加载并运行.class(0和1)

     跨平台、一次编程到处使用

   • 名词：

     • JVM: java虚拟机 加载并运行.class
     • JRE: java运行环境 JRE=JVM+java系统类库(小零件)
     • JDK: java开发工具包 JDK=JRE+开发工具

2. idea：

   • 开发步骤：

     • 新建Java项目----------------小区

     • 新建Java包-------------------楼+单元

     • 新建Java类-------------------房子

       ​ main：System.out.println(“hello world”);

   • 注释：解释性文本

     • 单行：//
     • 多行：/* */
     • 文档：/** */----------------API讲

笔记：

1. 变量：存数的

   • 声明：-------------相当于在银行开帐户

     int a; //声明一个整型的变量，名为a
     int b,c,d; //声明三个整型的变量，名为b,c,d
     //int a; //编译错误，变量不能同名
     

   • 初始化：第一次赋值---------相当于给帐户存钱

     int a = 250; //声明整型变量a并赋值为250
     int b;   //声明整型变量b
     b = 250; //给变量b赋值为250
     b = 360; //修改变量b的值为360
     int c=5,d=10; //声明两个整型变量c和d，并分别赋值为5和10
     

   • 使用：---------使用的是帐户里面的钱

     • 对变量的使用就是对它所存的那个数的使用

       int a = 5;
       int b = a+10; //取出a的值5，加10后，再赋值给变量b
       System.out.println(b);   //输出变量b的值15
       System.out.println("b"); //输出b，双引号中的原样输出
       a = a+10; //在a本身基础之上增10
       int c = 5000; //帐户余额
       c = c-1000; //取款1000
       

     • 变量在用之前必须声明并初始化

       //System.out.println(m); //编译错误，变量m未声明
       int m;
       //System.out.println(m); //编译错误，变量m未初始化
       

   • 命名：

     • 只能包含字母、数字、_和$符，并且不能以数字开头
     • 严格区分大小写
     • 不能使用关键字
     • 允许中文命名，但不建议，建议"英文的见名知意"、“小驼峰命名法”

     int a_5$,_3c,$_;
     //int a*b; //编译错误，不能包含*号等特殊符号
     //int 1a; //编译错误，不能以数字开头
     int aa = 5;
     //System.out.println(aA); //编译错误，严格区分大小写
     //int class; //编译错误，不能使用关键字
     
     int 年龄; //允许，但不建议
     int age; //建议"英文见名知意"
     int score,myScore,myJavaScore; //建议"小驼峰命名法"
     

2. 八种基本数据类型：byte,short,int,long,float,double,boolean,char

   • int：整型，4个字节，-21个多亿到21个多亿

     • 整数直接量默认为int类型，但不能超范围，若超范围则发生编译错误
     • 两个整数相除，结果还是整数，小数位无条件舍弃(不会四舍五入)
     • 整数运算时，若超出int范围则发生溢出(溢出不是错误，但需要避免)

     //1)int:整型，4个字节，-21个多亿到21个多亿
     int a = 25; //25称为整数直接量，默认int类型
     //int b = 10000000000; //编译错误，100亿默认为int类型，但超出int范围了
     //int c = 3.14; //编译错误，整型变量中只能装整数
     System.out.println(5/2); //2
     System.out.println(2/5); //0
     System.out.println(5/2.0); //2.5
     int d = 2147483647; //int的最大值
     d = d+1;
     System.out.println(d); //-2147483648(int最小值)，发生溢出了，溢出是需要避免的
     

   • long：长整型，8个字节，很大很大很大

     • 长整型直接量需在数字后加L或l
     • 运算时若有可能溢出，建议在第1个数字后加L

     //2)long:长整型，8个字节，很大很大很大
     long a = 25L; //25L为长整型直接量
     //long b = 10000000000; //编译错误，100亿默认为int类型，但超出int范围了
     long c = 10000000000L; //100L为长整型直接量
     //long d = 3.14; //编译错误，长整型变量只能装整数
     
     //运算时若有可能溢出，建议在第1个数字后加L
     long e = 1000000000*2*10L;
     System.out.println(e); //200亿
     long f = 1000000000*3*10L;
     System.out.println(f); //不是300亿
     long g = 1000000000L*3*10;
     System.out.println(g); //300亿
     

   • double：浮点型，8个字节，很大很大很大

     • 浮点数直接量默认为double型，若想表示float需在数字后加F或f
     • double与float型数据参与运算时，有可能会出现舍入误差，精确场合不能使用

     //3)double:浮点型，8个字节，很大很大很大
     double a = 3.14; //3.14为浮点数直接量，默认double型
     float b = 3.14F; //3.14F为float型直接量
     double c = 1234000000000000000000000000000000.0;
     System.out.println(c); //1.234E33，科学计数法表示，相当于1.234*(10的33次幂)
     
     double d=3.0,e=2.9;
     System.out.println(d-e); //0.10000000000000009，有可能会发生舍入误差，精确场合不能使用
     

   • boolean：布尔型，1个字节

     • 只能赋值为true或false

     //4)boolean:布尔型，1个字节
     boolean a = true;  //true为布尔型直接量-----真
     boolean b = false; //false为布尔型直接量----假
     //boolean c = 250; //编译错误，布尔型只能赋值为true或false
     

   • char：字符型，2个字节

     • 采用Unicode字符集编码格式，一个字符对应一个码

       表现的形式是字符char，但本质上是码int(0到65535之间)

       ASCII码：‘a’—97 ‘A’—65 ‘0’—48

     • 字符型直接量必须放在单引号中，并且只能有1个

     • 特殊符号需通过\来转义

     //5)char:字符型，2个字节
     char c1 = '女'; //字符女
     char c2 = 'f';  //字符f
     char c3 = '6';  //字符6
     char c4 = ' ';  //空格符
     //char c5 = 女; //编译错误，字符型直接量必须放在单引号中
     //char c6 = ''; //编译错误，必须有字符
     //char c7 = '女性'; //编译错误，只能有1个字符
     
     char c8 = 65; //0到65535之间
     System.out.println(c8); //println输出时会依据c8的数据类型显示
     //若c8为char型，则显示字符
     //若c8为int型，则显示数字
     char c9 = '\\';
     System.out.println(c9); //\
     

3. 类型间的转换：

   基本类型由小到大依次为：

   ​ byte----short----int----long----float----double

   ​ char----

   • 两种方式：

     • 自动/隐式类型转换：小类型到大类型

     • 强制类型转换：大类型到小类型

       ​ 语法：(要转换成为的数据类型)变量

       ​ 强转有可能溢出或丢失精度

     //类型间的转换:
     int a = 5;
     long b = a; //自动类型转换
     int c = (int)b; //强制类型转换
     
     long d = 5;   //自动类型转换
     double e = 5; //自动类型转换
     
     long f = 10000000000L;
     int g = (int)f; //强制类型转换
     System.out.println(g); //1410065408，强转有可能发生溢出
     double h = 25.987;
     int i = (int)h; //强制类型转换
     System.out.println(i); //25，强转有可能丢失精度
     

   • 两点规则：

     • 整数直接量可以直接赋值给byte,short,char，但不能超出范围
     • byte,short,char型数据参与运算时，系统一律自动将其转换为int再运算

     byte b1 = 5; //byte的范围为-128到127之间
     byte b2 = 6;
     byte b3 = (byte)(b1+b2);
     
     System.out.println(2+2);     //4
     System.out.println(2+'2');   //52，2加上'2'的码50
     System.out.println('2'+'2'); //100，'2'的码50，加上'2'的码50
     

精华笔记

1. 变量：存数的

   • 声明：相当于在银行开帐户

   • 初始化：第一次赋值，相当于给帐户存钱

   • 使用：使用的是帐户里面的钱

     • 对变量的使用就是对它所存的那个数的使用

     • 变量在用之前必须声明并初始化

   • 命名：

     • 只能包含字母、数字、_和$符，并且不能以数字开头
     • 严格区分大小写
     • 不能使用关键字
     • 允许中文命名，但不建议，建议"英文的见名知意"、“小驼峰命名法”

2. 八种基本数据类型：byte,short,int,long,float,double,boolean,char

   • int：整型，4个字节，-21个多亿到21个多亿

     • 整数直接量默认为int类型，但不能超范围，若超范围则发生编译错误
     • 两个整数相除，结果还是整数，小数位无条件舍弃(不会四舍五入)
     • 整数运算时，若超出int范围则发生溢出(溢出不是错误，但需要避免)

   • long：长整型，8个字节，很大很大很大

     • 长整型直接量需在数字后加L或l
     • 运算时若有可能溢出，建议在第1个数字后加L

   • double：浮点型，8个字节，很大很大很大

     • 浮点数直接量默认为double型，若想表示float需在数字后加F或f
     • double与float型数据参与运算时，有可能会出现舍入误差，精确场合不能使用

   • boolean：布尔型，1个字节

     • 只能赋值为true或false

   • char：字符型，2个字节

     • 采用Unicode字符集编码格式，一个字符对应一个码

       表现的形式是字符char，但本质上是码int(0到65535之间)

       ASCII码：‘a’—97 ‘A’—65 ‘0’—48

     • 字符型直接量必须放在单引号中，并且只能有1个

     • 特殊符号需通过\来转义

     • 

3. 类型间的转换：

   基本类型由小到大依次为：

   ​ byte----short----int----long----float----double

   ​ char----
   

   • 两种方式：

     • 自动/隐式类型转换：小类型到大类型

     • 强制类型转换：大类型到小类型

       ​ 语法：(要转换成为的数据类型)变量

       ​ 强转有可能溢出或丢失精度

   • 两点规则：

     • 整数直接量可以直接赋值给byte,short,char，但不能超出范围
     • byte,short,char型数据参与运算时，系统一律自动将其转换为int再运算

补充：

1. 数据类型分类：

   • 引用数据类型
   • 基本数据类型

2. 内存大小：

   1G=1024M(兆)
   1M=1024KB(千字节)
   1KB=1024B(字节)
   1B=8Bit(位)
   

语言基础第三天：

回顾：

1. 变量：存数的

   int a;  int b,c;
   int a = 5;  int a; a=5;
   int b = a+10;  System.out.println(a);
   a = a+10; //在a本身基础之上增10
   

2. 八种基本数据类型：byte,short,int,long,float,double,boolean,char

   • int：整型，4个字节，5,10,10000000…
   • long：长整型，8个字节，5L,100000000000000L…
   • double：浮点型，８个字节，3.14,54.0,5.678…
   • boolean：布尔型，1个字节，true,false
   • char：字符型，2个字节，‘你’,‘y’,‘4’,‘*’…

3. 类型间的转换：

   • 两种方式：自动/隐式、强制 (要转换成为的数据类型)变量

   • 两点规则：

     short s1 = 5;
     short s2 = 6;
     short s3 = (short)(s1+s2);
     

笔记：

1. 运算符：运算的符号

   • 算术：+，-，*，/，%，++，–

     • %:取模/取余，余数为0即为整除
     • ++/–：自增1/自减1，可在变量前也可在变量后
       • 单独使用时，在前在后都一样
       • 被使用时，在前在后不一样
         • a++的值为a--------(a–的值为a)
         • ++a的值为a+1------(–a的值为a-1)

     //%的演示
     System.out.println(8%2); //0，商4余0----整除
     System.out.println(5%2); //1，商2余1
     System.out.println(2%8); //2，商0余2
     
     //++单独使用:
     int a=5,b=5;
     a++; //相当于a=a+1
     ++b; //相当于b=b+1
     System.out.println(a); //6
     System.out.println(b); //6
     
     //++被使用:
     int a=5,b=5;
     int c = a++; //1)保存a++的值5  2)a自增1变为6  3)将第1步保存的值5赋值给c--底层运算过程
     //---粗暴记法:a++的值为5，c就是5
     int d = ++b; //1)保存++b的值6  2)b自增1变为6  3)将第1步保存的值6赋值给d--底层运算过程
     //---粗暴记法:++b的值为6，d就是6
     System.out.println(a); //6
     System.out.println(b); //6
     System.out.println(c); //5
     System.out.println(d); //6
     
     //--单独使用:
     int a=5,b=5;
     a--; //相当于a=a-1
     --b; //相当于b=b-1
     System.out.println(a); //4
     System.out.println(b); //4
     
     //--被使用:
     int a=5,b=5;
     int c = a--; //a--的值为5，所以c的值为5
     int d = --b; //--b的值为4，所以d的值为4
     System.out.println(a); //4
     System.out.println(b); //4
     System.out.println(c); //5
     System.out.println(d); //4
     

   • 关系：>，<，>=，<=，==，!=

     • 关系运算的结果为boolean型，
       关系成立则为true，关系不成立则为false

     int a=5,b=10,c=5;
     boolean b1 = a>b;
     System.out.println(b1);   //false
     System.out.println(c<b);  //true
     System.out.println(a>=c); //true
     System.out.println(a<=b); //true
     System.out.println(a==c); //true
     System.out.println(a!=c); //false
     
     System.out.println(a+c>b);  //false
     System.out.println(a%2==0); //false
     System.out.println(c++>5);  //false-------c自增1变为6
     System.out.println(c++>5);  //true--------c自增1变为7
     

   • 逻辑：&&，||，!

     • &&：短路与(并且)，两边都为真则为真，见false则false

     • ||：短路或(或者)，有真则为真，见true则true

     • !：逻辑非(取反)，非真则假，非假则真

     int a=5,b=10,c=5;
     //&&的演示:
     boolean b1 = b>=a && b<c;
     System.out.println(b1);          //true&&false=false
     System.out.println(b<=c && b>a); //false&&true=false
     System.out.println(a==b && c>b); //false&&false=false
     System.out.println(b!=c && a<b); //true&&true=true
     int age = 25;
     System.out.println(age>=18 && age<=50); //看age是否在18到50之间
     
     //||的演示:
     System.out.println(b>=a || b<c); //true||false=true
     System.out.println(b<=c || b>a); //false||true=true
     System.out.println(b!=c || a<b); //true||true=true
     System.out.println(a==b || c>b); //false||false=false
     int score = 89;
     System.out.println(score<0 || score>100); //看score是否不合法
     
     //!的演示
     boolean b2 = !(a<b);
     System.out.println(b2);     //!true=false
     System.out.println(!(a>b)); //!false=true
     
     //短路的演示
     int a=5,b=10,c=5;
     boolean b3 = a>b && c++>2;
     System.out.println(b3); //false
     System.out.println(c);  //5，发生短路了
     
     boolean b4 = a<b || c++>2;
     System.out.println(b4); //true
     System.out.println(c);  //5，发生短路了
     

   • 赋值：=，+=，-=，*=，/=，%=

     • 简单赋值运算符：=

     • 扩展赋值运算符：+=，-=，*=，/=，%=

     int a = 5;
     a += 10; //相当于a=(int)(a+10)
     System.out.println(a); //15
     a *= 2; //相当于a=(int)(a*2)
     System.out.println(a); //30
     a /= 6; //相当于a=(int)(a/6)
     System.out.println(a); //5
     
     //小面试题:
     short s = 5;
     //s = s+10; //编译错误，需强转: s=(short)(s+10);
     s += 10; //相当于s=(short)(s+10)
     

   • 字符串连接：+

     • +：
       • 若两边为数字，则做加法运算
       • 若两边出现了字符串，则做字符串连接
       • 任何类型与字符串相连，结果都会变为字符串类型----同化作用

     //字符串拼接演示
     int age = 38;
     System.out.println("age="); //age=
     System.out.println(age);    //38
     System.out.println("age="+age); //age=38
     System.out.println("我的年龄是"+age); //我的年龄是38
     System.out.println("我今年"+age+"岁了"); //我今年38岁了
     
     String name = "WKJ";
     System.out.println("name="+name); //name=WKJ
     System.out.println("大家好，我叫"+name); //大家好，我叫WKJ
     System.out.println("大家好，我叫"+name+"，今年"+age+"岁了"); //大家好，我叫WKJ，今年38岁了
     
     //同化作用演示
     System.out.println(10+20+30+""); //60---------String
     System.out.println(10+20+""+30); //3030-------String
     System.out.println(""+10+20+30); //102030-----String
     

   • 条件/三目：?:

     • 语法：

       ​ boolean?数1:数2

     • 执行过程：

       • 计算boolean的值：
         • 若为true，则整个表达式的值为?号后的数1
         • 若为false，则整个表达式的值为:号后的数2

     int num = 5;
     int flag = num>0?1:-1;
     System.out.println(flag); //1
     
     int a=8,b=55;
     int max = a>b?a:b;
     System.out.println("max="+max);
     

2. 分支结构：基于条件执行某语句

   • if结构：1条路

     • 语法：

       if(boolean){
       语句块
       }

     • 执行过程：

       ​ 判断boolean的值:
       ​ 若为true，则执行语句块1(if整个结束)
       ​ 若为false，则if直接结束

     //1)偶数的判断:
     int num = 5;  //带数(6,5)
     if(num%2==0){
         System.out.println(num+"是偶数");
     }
     System.out.println("继续执行...");
     
     //2)满500打8折:
     double price = 300.0; //消费金额  带数(600.0,300.0)
     if(price>=500){ //满500
         price *= 0.8; //打8折
     }
     System.out.println("最终结算金额为:"+price);
     
     //3)判断年龄是否在18到50之间，若满足则输出:"满足条件"
     int age = 88;  //带数(25,5,88)
     if(age>=18 && age<=50){
         System.out.println("年龄满足条件");
     }
     System.out.println("继续执行...");
     

   • if…else结构：2条路

     • 语法：

       ​ if(boolean){
       ​ 语句块1
       ​ }else{
       ​ 语句块2
       ​ }

     • 执行过程：

       ​ 判断boolean的值:
       ​ 若为true，则执行语句块1(整个结束)
       ​ 若为false，则执行语句块2(整个结束)

     • 说明：

       ​ 语句块1和语句块2，必走其中之一------------2选1

     //1)偶数、奇数的判断:
     int num = 5;  //带数(6,5)
     if(num%2==0){
         System.out.println(num+"是偶数");
     }else{
         System.out.println(num+"是奇数");
     }
     System.out.println("继续执行...");
     
     //2)满500打8折，不满500打9折:
     double price = 300.0;  //带数(600.0,300.0)
     if(price>=500){ //满500
         price *= 0.8;
     }else{ //不满500
         price *= 0.9;
     }
     System.out.println("最终结算金额为:"+price);
     
     //3)判断成绩是否合法，合法则输出"该成绩合法"，否则输出"该成绩不合法":
     int score = 560; //带数(95,-90,560)
     if(score<0 || score>100){
         System.out.println("该成绩不合法");
     }else{
         System.out.println("该成绩合法");
     }
     System.out.println("继续执行...");
     

精华笔记：

1. 运算符：运算的符号

   • 算术：+，-，*，/，%，++，–

   • 关系：>，<，>=，<=，==，!=

   • 逻辑：&&，||，！

   • 赋值：=，+=，-=，*=，/=，%=

   • 字符串连接：+

   • 条件/三目：?:

2. 分支结构：基于条件执行某语句

   • if结构：1条路
   • if…else结构：2条路

补充：

1. &为不短路与，|为不短路或
2. 任何复杂的程序逻辑都可以通过三种结构来实现：
   • 顺序结构：从上往下逐行执行，每句必走
   • 分支结构：有条件的执行某语句，并非每句必走
   • 循环结构：明天讲

语言基础第四天：

回顾：

1. 运算符：
   • 算术：+，-，*，/，%，++，–
   • 关系：>，<，>=，<=，==，!= boolean
   • 逻辑：&&，||，! boolean
   • 赋值：=，+=，-=，*=，/=，%=
   • 字符串连接：+
   • 条件/三目：boolean?数1:数2
2. 分支结构：基于条件执行的语句
   • if结构：1条路
   • if…else结构：2条路

笔记：

1. Scanner接收用户输入的数据：共3步，不需要理解，先背下来

   • 在package下：

     ​ import java.util.Scanner;

   • 在main中：

     ​ Scanner scan = new Scanner(System.in);

   • 在第2步之下：

     ​ System.out.println(“请输入年龄:”);
     ​ int age = scan.nextInt();
     ​ System.out.println(“请输入商品价格:”);
     ​ double price = scan.nextDouble();

   package day04;
   import java.util.Scanner; //1.导入一个扫描仪
   //Scanner的演示
   public class ScannerDemo {
       public static void main(String[] args) {
           Scanner scan = new Scanner(System.in); //2.新建一个扫描仪
           System.out.println("请输入年龄:");
           int age = scan.nextInt(); //3.扫描一个整数给age
           System.out.println("请输入商品价格:");
           double price = scan.nextDouble(); //3.扫描一个小数给price
           System.out.println("年龄为:"+age+"，价格为:"+price);
       }
   }
   

2. 分支结构：

   • if…else if结构：多条路

     • 语法：

       if(boolean-1){
       语句块1
       }else if(boolean-2){
       语句块2
       }else if(boolean-3){
       语句块3
       }else{
       语句块4
       }

     • 执行过程：

       判断boolean-1，若为true则执行语句块1(结束)，若为false则
       再判断boolean-2，若为true则执行语句块2(结束)，若为false则
       再判断boolean-3，若为true则执行语句块3(结束)，若为false则 执行语句块4(结束)

     • 说明：

       语句块1/2/3/4，只能执行其中之一------------多选1

     public class ScoreLevel {
         public static void main(String[] args) {
             Scanner scan = new Scanner(System.in);
             System.out.println("请输入成绩:");
             double score = scan.nextDouble();
     
             //带数(-25,888,95,85,65,45)
             if(score<0 || score>100){
                 System.out.println("成绩不合法");
             }else if(score>=90){ //合法
                 System.out.println("A-优秀");
             }else if(score>=80){
                 System.out.println("B-良好");
             }else if(score>=60){
                 System.out.println("C-中等");
             }else{
                 System.out.println("D-不及格");
             }
         }
     }
     

   • switch…case结构：多条路

     优点：效率高、结构清晰

     缺点：只能对整数判断相等

     break：跳出switch

     public class CommandBySwitch {
         public static void main(String[] args) {
             Scanner scan = new Scanner(System.in);
             System.out.println("请选择功能: 1.取款  2.存款  3.查询余额  0.退卡");
             int command = scan.nextInt();
     
             switch(command){
                 case 1:
                     System.out.println("取款操作...");
                     break;
                 case 2:
                     System.out.println("存款操作...");
                     break;
                 case 3:
                     System.out.println("查询余额操作...");
                     break;
                 case 0:
                     System.out.println("退卡操作...");
                     break;
                 default:
                     System.out.println("输入错误");
             }
         }
     }
     

3. 循环：反复多次执行一段相同或相似的代码

4. 循环三要素：

   • 循环变量的初始化

   • 循环的条件(以循环变量为基础)

   • 循环变量的改变(向着循环的结束变)

   //跑3圈:
   循环变量:所跑圈数count
   1)int count=0;
   2)count<3
   3)count++;
     count=0/1/2/ 3时结束
   
                        圈数为0
   够3圈吗？ 不够  跑一圈  圈数为1
   够3圈吗？ 不够  跑一圈  圈数为2
   够3圈吗？ 不够  跑一圈  圈数为3
   够3圈吗？ 够了
   
   //打印机打印6份简历:
   循环变量:所打份数num
   1)int num=0;
   2)num<6
   3)num++;
     num=0/1/2/3/4/5/ 6时结束
                         份数为0
   够6份吗？ 不够  打印一份  份数为1
   够6份吗？ 不够  打印一份  份数为2
   够6份吗？ 不够  打印一份  份数为3
   够6份吗？ 不够  打印一份  份数为4
   够6份吗？ 不够  打印一份  份数为5
   够6份吗？ 不够  打印一份  份数为6
   够6份吗？ 够了
   

5. 循环结构：

   • while结构：先判断后执行，有可能一次都不执行

     • 语法：

       while(boolean){
       语句块-------------反复执行的代码
       }

     • 执行过程：

       ​ 判断boolean的值，若为true则执行语句块，
       ​ 再判断boolean的值，若为true则再执行语句块，
       ​ 再判断boolean的值，若为true则再执行语句块，
       ​ 如此反复，直到boolean的值为false时，while循环结束

     • 代码演示：

       //1)输出5次"行动是成功的阶梯":
       int times = 0;  //1)循环变量的初始化
       while(times<5){ //2)循环的条件
           System.out.println("行动是成功的阶梯");
           times++;    //3)循环变量的改变
       }
       System.out.println("继续执行...");
       
       /*
         执行过程:----带数
                       times=0
           true  输出  times=1
           true  输出  times=2
           true  输出  times=3
           true  输出  times=4
           true  输出  times=5
           false while循环结束
           输出继续执行...
        */
       
       //2)输出9的乘法表:
       int num = 1;     //3*9=27
       while(num<=9){
           System.out.println(num+"*9="+num*9);
           num++;  //num+=2;
       }
       System.out.println("继续执行...");
       

     • 猜数字小游戏代码：

       public class Guessing {
           public static void main(String[] args) {
               Scanner scan = new Scanner(System.in);
               int num = (int)(Math.random()*1000+1); //1到1000之内的随机数
               System.out.println(num); //作弊
       
               //300(大),200(小),250(对)
               System.out.println("猜吧!");
               int guess = scan.nextInt(); //1.
               while(guess!=num){ //2.
                   if(guess>num){
                       System.out.println("太大了");
                   }else{
                       System.out.println("太小了");
                   }
                   System.out.println("猜吧!");
                   guess = scan.nextInt(); //3.
               }
               System.out.println("恭喜你猜对了!");
           }
       }
       

   • do…while结构：先执行后判断，至少执行一次

     • 语法：

       do{
       语句块
       }while(boolean);

     • 执行过程：

       ​ 先执行语句块，再判断boolean的值，若为true则
       ​ 再执行语句块，再判断boolean的值，若为true则
       ​ 再执行语句块，再判断boolean的值，若为true则
       ​ 再执行语句块，如此反复，直到boolean的值为false，则 do…while结束

     • 猜数字小游戏代码：

       public class Guessing {
           public static void main(String[] args) {
               Scanner scan = new Scanner(System.in);
               int num = (int)(Math.random()*1000+1); //1到1000之内的随机数
               System.out.println(num); //作弊
       
               //假设num=250
               //300(大),200(小),250(对)
               int guess;
               do{
                   System.out.println("猜吧!");
                   guess = scan.nextInt(); //1+3
                   if(guess>num){
                       System.out.println("太大了");
                   }else if(guess<num){
                       System.out.println("太小了");
                   }else{
                       System.out.println("恭喜你猜对了");
                   }
               }while(guess!=num); //2
           }
       }
       

   补充：

   1. 变量的作用域/范围：

      • 从变量的声明开始，到包含它最近的大括号结束

   2. 生成随机数：

      int num = (int)(Math.random()*1000+1); //1到1000
      
      Math.random()--------------0.0到0.9999999999999999...
      *1000----------------------0.0到999.99999999999999...
      +1-------------------------1.0到1000.9999999999999...
      (int)----------------------1到1000
      

   3. 任何复杂的程序逻辑都可以通过三种结构来实现：

      • 顺序结构：从上往下逐行执行，每句必走

      • 分支结构：有条件的执行某语句一次，并非每句必走

      • 循环结构：有条件的执行某语句多次，并非每句必走

   精华笔记：

   1. Scanner接收用户输入的数据：共3步，不需要理解，先背下来

   2. 分支结构：

      • if…else if结构：多条路

      • switch…case结构：多条路

        优点：效率高、结构清晰

        缺点：只能对整数判断相等

        break：跳出switch

   3. 循环：反复多次执行一段相同或相似的代码

   4. 循环三要素：

      • 循环变量的初始化

      • 循环的条件(以循环变量为基础)

      • 循环变量的改变(向着循环的结束变)

   5. 循环结构：

      • while结构：先判断后执行，有可能一次都不执行

      • do…while结构：先执行后判断，至少执行一次

      语言基础第五天：

回顾：

1. Scanner接收用户的数据：共3步

2. 分支结构：

   • if…else if结构：多条路

   • switch…case结构：多条路

     优点：效率高、结构清晰

     缺点：只能对整数判断相等

     break：跳出switch

3. 循环：反复多次执行一段相同或相似的代码

4. 循环三要素：

   • 循环变量的初始化

   • 循环的条件(以循环变量为基础)

   • 循环变量的改变(向着循环的结束变)

5. 循环结构：

   • while结构：先判断后执行，有可能一次都不执行

   • do…while结构：先执行后判断，至少执行一次

笔记：

1. 循环结构：

   • for结构：应用率高、与次数相关的循环

     • 语法：

       ​ // 1 2 3

       ​ for(要素1;要素2;要素3){

       ​ 语句块/循环体----------------反复执行的代码 4

       ​ }

     • 执行过程：

       ​ 1243243243243243243…2

     • 代码演示：

       //for循环中的循环变量i，作用域仅在当前for中
       for(int i=1;i<=9;i++){
           System.out.println(i+"*9="+i*9);
       }
       for(int i=1;i<=9;i+=2){
           System.out.println(i+"*9="+i*9);
       }
       for(int i=9;i>=1;i--){
           System.out.println(i+"*9="+i*9);
       }
       
       for(int times=0;times<5;times++){
           System.out.println("行动是成功的阶梯");
       }
       System.out.println("继续执行...");
       /*
       执行过程:
       times=0  true  输出
           times=1  true  输出
           times=2  true  输出
           times=3  true  输出
           times=4  true  输出
           times=5  false for循环结束
           输出继续执行...
       */
       
       //for的特殊格式:----------了解
       int i=1;
       for(;i<=9;i++){
           System.out.println(i+"*9="+i*9);
       }
       for(int i=1;i<=9;){
           System.out.println(i+"*9="+i*9);
           i++;
       }
       for(;;){ //没有条件的循环就是一个死循环
           System.out.println("我要学习...");
       }
       
       for(int i=1,j=5;i<=5;i+=2,j-=2){
       }
       /*
         i=1,j=5  true
         i=3,j=3  true
         i=5,j=1  true
         i=7,j=-1 false
        */
       

2. 三种循环结构的选择规则：

   • 先看循环是否与次数相关：
     • 若相关----------------------------直接上for
     • 若无关，再看要素1与要素3是否相同：
       • 若相同------------------------直接上do…while
       • 若不同------------------------直接上while

3. break：跳出循环

   for(int i=1;i<=9;i++){
       if(i==4){ //在某种特定条件下，提前结束循环
           break;
       }
       System.out.println(i+"*9="+i*9);
   }
   /* 
     i=1  true  1*9=9
     i=2  true  2*9=18
     i=3  true  3*9=27
     i=4  true
   */        
   

   continue：跳过循环体中剩余语句而进入下一次循环

   //输出9的乘法表，只要不能被3整除的
   for(int i=1;i<=9;i++){
       if(i%3!=0){
           System.out.println(i+"*9="+i*9);
       }
   }
   
   
   //输出9的乘法表，跳过能被3整除的
   for(int i=1;i<=9;i++){
       if(i%3==0){
           continue; //跳过循环体中剩余语句而进入下一次循环
       }
       System.out.println(i+"*9="+i*9);
   }
   /*
       i=1  1*9=9
       i=2  2*9=18
       i=3
       i=4  4*9=36
       i=5  5*9=45
       i=6
       i=7  7*9=63
       i=8  8*9=72
       i=9
       i=10
   */
   

4. 随机加法运算器案例：

   package day05;
   import java.util.Scanner;
   //随机加法运算器
   public class Addition {
       public static void main(String[] args) {
           Scanner scan = new Scanner(System.in);
           int score = 0; //总分
           for(int i=1;i<=10;i++) { //10次
               int a = (int)(Math.random()*100); //加数a，0到99之间
               int b = (int)(Math.random()*100); //加数b
               int result = a+b; //存正确答案
               System.out.println("("+i+")"+a+"+"+b+"=?"); //1)出题
   
               System.out.println("算吧!----输入-1可提前结束");
               int answer = scan.nextInt(); //2)答题
   
               if(answer==-1){ //3)判题
                   break;
               }
               if(answer==result){
                   System.out.println("答对了");
                   score += 10; //答对1题，加10分
               }else{
                   System.out.println("答错了");
               }
           }
           System.out.println("总分为:"+score);
       }
   }
   

5. 嵌套循环：

   • 循环中套循环，常常多行多列时使用，一般外层控制行，内层控制列
   • 执行过程：外层循环走一次，内层循环走所有次
   • 建议：嵌套层数越少越好，能用一层就不用两层，能用两层就不用三层，若业务必须通过三层以上的循环才能解决，说明你的设计有问题
   • break只能跳出当前一层循环

   for(int num=1;num<=9;num++){ //控制行
       for(int i=1;i<=num;i++){ //控制列
           System.out.print(i+"*"+num+"="+i*num+"\t");
       }
       System.out.println(); //换行
   }
   /*
     执行过程:
       num=3
         i=1  1*3=3
         i=2  2*3=6
         i=3  3*3=9
         i=4  false
         换行
       num=2
         i=1  1*2=2
         i=2  2*2=4
         i=3  false
         换行
       num=1
         i=1  1*1=1
         i=2  false
         换行
    */
   

6. 数组：

   • 是一种数据类型(引用类型)

   • 相同数据类型元素的集合

   • 定义：

     //声明int型数组arr，包含10个元素，每个元素都是int型，默认值为0
     int[] arr = new int[10];
     

   • 初始化：给数组中的元素做初始化

     int[] arr = new int[3]; //0,0,0
     int[] arr = {1,4,7}; //1,4,7
     int[] arr = new int[]{1,4,7}; //1,4,7
     int[] arr;
     //arr = {1,4,7}; //编译错误
     arr = new int[]{1,4,7}; //正确
     

   • 访问：访问的是数组中的元素

     • 通过(数组名.length)可以获取数组的长度(元素的个数)

       int[] arr = new int[3];
       System.out.println(arr.length); //3
       

     • 通过下标/索引来访问数组中的元素

       下标从0开始，最大到(数组的长度-1)

       int[] arr = new int[3];
       arr[0] = 100; //给第1个元素赋值为100
       arr[1] = 200; //给第2个元素赋值为200
       arr[2] = 300; //给第3个元素赋值为300
       System.out.println(arr[arr.length-1]); //输出最后一个元素的值
       

   • 遍历/迭代：从头到尾挨个走一遍

     int[] arr = new int[10];
     for(int i=0;i<arr.length;i++){ //遍历arr数组
         //arr[i]代表arr中的每一个元素
         //给每个元素赋值为0到99之间的随机数
         arr[i] = (int)(Math.random()*100); 
         System.out.println(arr[i]); //输出每个元素的值
     }
     

精华笔记：

1. 循环结构：

   • for结构：应用率高、与次数相关的循环

2. 三种循环结构的选择规则：

   • 先看循环是否与次数相关：
     • 若相关----------------------------直接上for
     • 若无关，再看要素1与要素3是否相同：
       • 若相同------------------------直接上do…while
       • 若不同------------------------直接上while

3. break：跳出循环

   continue：跳过循环体中剩余语句而进入下一次循环

4. 嵌套循环：

   • 循环中套循环，常常多行多列时使用，一般外层控制行，内层控制列
   • 执行过程：外层循环走一次，内层循环走所有次
   • 建议：嵌套层数越少越好，能用一层就不用两层，能用两层就不用三层，若业务必须通过三层以上的循环才能解决，说明你的设计有问题
   • break只能跳出当前一层循环

5. 数组：

   • 是一种数据类型(引用类型)

   • 相同数据类型元素的集合

   • 定义：

   • 初始化：给数组中的元素做初始化

   • 访问：访问的是数组中的元素

     • 通过(数组名.length)可以获取数组的长度(元素的个数)

     • 通过下标/索引来访问数组中的元素

       下标从0开始，最大到(数组的长度-1)

   • 遍历/迭代：从头到尾挨个走一遍

补充：

1. 变量的同名问题：
   • 作用域重叠时，变量不能同名的
2. \t：水平制表位，固定占8位
3. ArrayIndexOutOfBoundsException数组下标越界异常
   • 数组下标范围为0到(数组长度-1)，超出范围则发生如上的异常

语言基础第六天：

回顾：

1. 循环结构：

   • for：应用率高、与次数相关

2. 选择原则：

3. break：跳出循环

   continue：跳过循环体中剩余语句而进入下一次循环

4. 嵌套循环:

   ​ 循环中套循环，外层循环走一次，内层循环走所有次

   ​ 越少越好，break只能跳出当前一层循环

5. 数组：

   ​ 引用类型，相同数据类型元素的集合

   ​ int[ ] arr = new int[3]; //0,0,0

   ​ int[ ] arr = {2,4,6};

   ​ int[ ] arr = new int[ ]{2,4,6};

   ​ System.out.println(arr[0]);

   ​ arr[1] = 100;

   ​ System.out.println(arr[arr.length-1]);

   ​ for(int i=0;i<arr.length;i++){

   ​ arr[i] = (int)(Math.random()*100);

   ​ System.out.println(arr[i]);

   ​ }

笔记：

1. 数组：

   • 复制：

     • System.arraycopy(a,1,b,0,4);

       //7)数组的复制:
       int[] a = {10,20,30,40,50};
       int[] b = new int[6]; //0,0,0,0,0,0
       //a:源数组
       //1:源数组的起始下标
       //b:目标数组
       //0:目标数组的起始下标
       //4:要复制的元素个数
       System.arraycopy(a,1,b,0,4); //灵活性好
       for(int i=0;i<b.length;i++){
           System.out.println(b[i]);
       }
       
       

     • int[ ] b = Arrays.copyOf(a,6);

       //常规复制
       int[] a = {10,20,30,40,50};
       //a:源数组
       //b:目标数组
       //6:目标数组的长度(元素个数)
       //---若目标数组长度>源数组长度，则末尾补默认值
       //---若目标数组长度<源数组长度，则将末尾的截掉
       int[] b = Arrays.copyOf(a,6); //灵活性差
       for(int i=0;i<b.length;i++){
           System.out.println(b[i]);
       }
       
       //数组的扩容
       int[] a = {10,20,30,40,50};
       //数组扩容(创建了一个更大的新的数组，并将源数组数据复制进去了)
       a = Arrays.copyOf(a,a.length+1);
       for(int i=0;i<a.length;i++){
           System.out.println(a[i]);
       }
       

     • 综合案例：

       package day06;
       import java.util.Arrays;
       //求数组元素的最大值，并将最大值放在数组最后一个元素的下一个位置
       public class MaxOfArray {
           public static void main(String[] args) {
               int[] arr = new int[10];
               for(int i=0;i<arr.length;i++){
                   arr[i] = (int)(Math.random()*100);
                   System.out.println(arr[i]);
               }
       
               int max = arr[0]; //假设第1个元素为最大值
               for(int i=1;i<arr.length;i++){ //遍历剩余元素
                   if(arr[i]>max){ //若剩余元素大于max
                       max = arr[i]; //则修改max为较大的
                   }
               }
               System.out.println("最大值为:"+max);
       
               arr = Arrays.copyOf(arr,arr.length+1); //扩容
               arr[arr.length-1] = max; //将最大值max赋值给arr中的最后一个元素
               for(int i=0;i<arr.length;i++){
                   System.out.println(arr[i]);
               }
           }
       }
       

   • 排序：

     • Arrays.sort(arr); //升序排列(从小到大)

       //8)数组的排序:
       int[] arr = new int[10];
       for(int i=0;i<arr.length;i++){
           arr[i] = (int)(Math.random()*100);
           System.out.println(arr[i]);
       }
       
       Arrays.sort(arr); //对arr进行升序排列
       
       System.out.println("数组排序后的数据:");
       for(int i=0;i<arr.length;i++){
           System.out.println(arr[i]);
       }
       
       System.out.println("倒序输出:");
       for(int i=arr.length-1;i>=0;i--){
           System.out.println(arr[i]);
       }
       

2. 方法：函数、过程

   • 封装一段特定的业务逻辑功能
   • 尽可能的独立，一个方法只干一件事
   • 方法可以被反复多次调用
   • 减少代码重复，有利于代码复用，有利于代码维护

3. 定义方法：五要素

   ​ 修饰词 返回值类型 方法名(参数列表) {

   ​ 方法体--------------具体的业务逻辑功能实现

   ​ }

   //无参无返回值
   public static void say(){
       System.out.println("大家好，我叫WKJ，今年38岁了");
   }
   //有参无返回值
   public static void sayHi(String name){ //---------形参
       System.out.println("大家好，我叫"+name+"，今年38岁了");
   }
   //有参无返回值
   public static void sayHello(String name,int age){
       if(age>=35){ //在某种特定条件下，提前结束方法
           return; //结束方法
       }
       System.out.println("大家好，我叫"+name+"，今年"+age+"岁了");
   }
   
   //无参有返回值
   public static double getNum(){
       //在有返回值的方法中:
       //--必须得通过return来返回一个值，并且这个值的类型必须与返回值类型匹配
       //return "abc"; //编译错误，返回的值必须与返回值类型匹配
       return 8.88; //1)结束方法的执行  2)返回一个结果给调用方
   }
   
   //有参有返回值
   public static int plus(int num1,int num2){
       int num = num1+num2;
       return num; //返回的是num里面的那个数
       //return num1+num2; //返回的是num1与num2的和
   }
   //获取指定整型数组元素的最小值
   public static int getMinOfArray(int[] arr){
       int min = arr[0]; //假设第1个元素为最小值
       for(int i=1;i<arr.length;i++){
           if(arr[i]<min){
               min = arr[i];
           }
       }
       return min;
   }
   

4. 调用方法：

   • 无返回值：方法名(有参传参);
   • 有返回值：数据类型 变量 = 方法名(有参传参);

   //say();
   
   //sayHi(); //编译错误，有参则必须传参
   //sayHi(250); //编译错误，参数类型必须匹配
   sayHi("zhangsan"); //String name="zhangsan" //-------实参
   sayHi("lisi"); //String name="lisi" //---------------实参
   sayHi("wangwu"); //String name="wangwu" //-----------实参
   
   sayHello("zhangsan",25); //实参
   sayHello("WKJ",38); //实参
   
   double a = getNum(); //getNum()的值就是8.88
   System.out.println(a); //8.88----模拟对返回值的后续操作
   
   int b = plus(5,6);
   System.out.println(b); //11----模拟对返回值的后续操作
   
   int m=5,n=6;
   int c = plus(m,n); //传递的是m和n里面的那个数
   System.out.println(c); //11----模拟对返回值的后续操作
   
   int[] arr = {13,45,1,35};
   int min = getMinOfArray(arr);
   System.out.println(min); //1----模拟对返回值的后续操作
   
   int[] a = new int[10];
   for(int i=0;i<a.length;i++){
       a[i] = (int)(Math.random()*100);
   }
   int b = getMinOfArray(a);
   System.out.println(b);
   

5. return：

   • return 值; //1)结束方法的执行 2)返回结果给调用方

     ​ ----------用在有返回值方法中

   • return; //1)结束方法的执行-----------------用在无返回值的方法中

精华笔记：

1. 数组：

   • 复制：

     • System.arraycopy(a,1,b,0,4);

     • int[ ] b = Arrays.copyOf(a,6);

   • 排序：

     • Arrays.sort(arr); //升序排列(从小到大)

2. 方法：函数、过程

   • 封装一段特定的业务逻辑功能
   • 尽可能的独立，一个方法只干一件事
   • 方法可以被反复多次调用
   • 减少代码重复，有利于代码复用，有利于代码维护

3. 定义方法：五要素

   ​ 修饰词 返回值类型 方法名(参数列表) {

   ​ 方法体--------------具体的业务逻辑功能实现

   ​ }

4. 调用方法：

   • 无返回值：方法名(有参传参);
   • 有返回值：数据类型 变量 = 方法名(有参传参);

5. return：

   • return 值; //1)结束方法的执行 2)返回结果给调用方

     ​ ----------用在有返回值方法中

   • return; //1)结束方法的执行

     ​ -----------------用在无返回值的方法中

补充：

1. 形参：形式参数，定义方法时的参数为形参

   实参：实际参数，调用方法时的参数为实参

public static void main(String[] args){
    say();
    sayHi("zhangsan");
    sayHello("zhangsan",25);
    double a = getNum(); //输出a(模拟对返回值的后续操作)
    int b=plus(5,6); //输出b(模拟对返回值的后续操作)
    int m=5,n=6;int c=plus(m,n); //输出c(模拟对返回值的后续操作)
    int[] arr={2,4,3};
    int d = getMinOfArray(arr); //输出d(模拟对返回值的后续操作)
}
public static void say(){...}
public static void sayHi(String name){...}
public static void sayHello(String name,int age){...}
public static double getNum(){ return 8.88; }
public static int plus(int num1,int num2){
    int num = num1+num2;  return num;  //return num1+num2;
}
public static int getMinOfArray(int[] arr){ ... }

方法可以有参，也可以无参
----有参可以使方法更加灵活
    
何时有参？何时无参？
1)若方法中的数据都可以写成固定/写死的---------无参
2)若方法中的数据不是固定的数据-----------有参
    
double c = Math.random(); //0.0到0.9999999999999... 

假设random()有参:
  double c = Math.random(1,1000);
  double c = Math.random(0,99);
  double c = Math.random(20,50);

System.out.            println("hello");
System.                arraycopy(a,1,b,0,4);
Arrays.                sort(arr);
int[]  b = Arrays.     copyOf(a,6); //--------有参数

int    a = scan.       nextInt();
double b = scan.       nextDouble();
double c = Math.       random(); //-----------无参数

方法可以有返回值，也可以没有返回值
1)无返回值: 返回值类型统一设计为void
2)有返回值: 返回值类型设计为特定的数据类型即可
    
何时有返回值？何时没有返回值？
---方法操作完成后:
   1)若还需要用到方法中的某个数据---------有返回值
   2)若不需要用到方法中的数据------------无返回值

System.out.println("hello");
System.arraycopy(a,1,b,0,4);
Arrays.sort(arr); //-------------------没有返回值

int    a = scan.nextInt();
double b = scan.nextDouble();
double c = Math.random();
int[]  b = Arrays.copyOf(a,6); //------有返回值

面向对象第一天：

潜艇游戏第一天：

1. 创建6个类，创建World类并测试

回顾：

1. 数组：

   • 复制：

     • System.arraycopy(a,1,b,0,4);

     • int[] b = Arrays.copyOf(a,6);

       a = Arrays.copyOf(a,a.length+1);

   • 排序：

     • Arrays.sort(arr);

2. 方法：函数、过程

   ​ 封装一段特定的业务逻辑功能、只干一件事、可以被反复调用、

   ​ 减少代码重复，有利于代码的复用、有利于代码的维护

3. 方法的定义：

   ​ 修饰词 返回值类型 方法名(参数列表) {

   ​ 方法体

   ​ }

4. 方法的调用：

   • 无返回值：方法名(有参传参);
   • 有返回值：数据类型 变量 = 方法名(有参传参);

5. return：

   • return 值; //1)结束方法 2)返回结果给调用方
   • return; //1)结束方法

笔记：

1. 什么是类？什么是对象？

   • 现实生活中是由很多很多对象组成的，基于对象抽出了类

   • 对象：软件中真实存在的单个个体/东西

     类：类别/类型，代表一类个体

   • 类是对象的模子，对象是类的具体的实例

   • 类中可以包含：

     • 对象的属性/特征-----------------------成员变量
     • 对象的行为/动作-----------------------方法

   • 一个类可以创建多个对象

2. 如何创建类？如何创建对象？如何访问成员？

   public class Student { //Student类就是我们自己造的一种引用类型
       //成员变量
       String name;
       int age;
       String address;
       //方法
       void study(){
           System.out.println(name+"在学习...");
       }
       void sayHi(){
           System.out.println("大家好，我叫"+name+"，今年"+age+"岁了，家住"+address);
       }
   }
   
   public class StudentTest {
       public static void main(String[] args){
           //创建一个学生对象
           Student zs = new Student();
           //给成员变量赋值
           zs.name = "zhangsan";
           zs.age = 25;
           zs.address = "河北廊坊";
           //调用方法
           zs.study();
           zs.sayHi();
   
           Student ls = new Student();
           ls.name = "lisi";
           ls.age = 24;
           ls.address = "黑龙江佳木斯";
           ls.study();
           ls.sayHi();
   
           //1)创建了一个学生对象
           //2)给所有成员变量赋默认值
           Student ww = new Student();
           ww.study();
           ww.sayHi();
   
       }
   }
   

3. 方法的重载(overload/overloading)：---------------更加方便用户的访问

   • 发生在同一类中，方法名相同，参数列表不同
   • 编译器在编译时会根据方法的签名自动绑定方法

   //重载的演示
   public class OverloadDemo {
       public static void main(String[] args) {
           Aoo o = new Aoo();
           o.show(); //编译器根据方法的签名自动绑定方法
           o.show("zhangsan");
           o.show(25);
           o.show("zhangsan",25);
           o.show(25,"zhangsan");
       }
   }
   
   class Aoo{
       void show(){}
       void show(String name){}
       void show(int age){}
       void show(String name,int age){}
       void show(int age,String name){}
       //int show(){ return 1;} //编译错误，重载与返回值类型无关
       //void show(String address){} //编译错误，重载与参数名称无关
   }
   

精华笔记：

1. 什么是类？什么是对象？

   • 现实生活中是由很多很多对象组成的，基于对象抽出了类

   • 对象：软件中真实存在的单个个体/东西

     类：类别/类型，代表一类个体

   • 类是对象的模子，对象是类的具体的实例

   • 类中可以包含：

     • 对象的属性/特征-----------------------成员变量
     • 对象的行为/动作-----------------------方法

   • 一个类可以创建多个对象

2. 如何创建类？如何创建对象？如何访问成员？

3. 方法的重载(overload/overloading)：---------------更加方便用户的访问

   • 发生在同一类中，方法名相同，参数列表不同
   • 编译器在编译时会根据方法的签名自动绑定方法

潜艇游戏需求：

1. 所参与的角色：
   • 战舰、深水炸弹、侦察潜艇、鱼雷潜艇、水雷潜艇、水雷
2. 角色间的关系：
   • 战舰发射深水炸弹
   • 深水炸弹可以打潜艇(侦察潜艇、鱼雷潜艇、水雷潜艇)，若打中：
     • 潜艇消失、深水炸弹消失
     • 得东西：
       • 打掉侦察潜艇，玩家得10分
       • 打掉鱼雷潜艇，玩家得40分
       • 打掉水雷潜艇，战舰得1条命
   • 水雷潜艇可以发射水雷
   • 水雷可以击打战舰，若击中：
     • 水雷消失
     • 战舰减1条命(命数为0时游戏结束)

补充：

1. 高质量的代码：---------------------以后的目标、拿年薪

   • 复用性好、扩展性好、维护性好、可移植性好\健壮性好、可读性好、效率好…

2. 默认值规则：

   byte,short,int,long,char-------------0
   float,double-------------------------0.0
   boolean------------------------------false
   引用类型------------------------------null  
   

3. //若想访问对象，需要通过引用zs
               引用
   数据类型  引用类型变量   指向       对象
   Student     zs         =    new Student(); 
   

4. 方法的签名：方法名+参数列表

面向对象第二天：

潜艇游戏第一天：

1. 创建6个类，创建World类并测试

潜艇游戏第二天：

1. 给6个类添加构造方法，并测试

回顾：

1. 什么是类？什么是对象？
2. 如何创建类？如何创建对象？如何访问成员？
3. 方法的重载(overload)：-----------------方便用户的调用
   • 发生在同一类中，方法名相同，参数列表不同
   • 编译器在编译时会根据方法的签名自动绑定方法

笔记：

1. 构造方法：构造函数、构造器、构建器---------复用给成员变量赋初值代码

   • 作用：给成员变量赋初始值
   • 与类同名，没有返回值类型(连void都没有)
   • 在创建(new)对象时被自动调用
   • 若自己不写构造方法，则编译器默认提供一个无参构造方法，若自己写了构造方法，则不再默认提供
   • 构造方法可以重载

2. this：指代当前对象，哪个对象调用方法它指的就是哪个对象

   ​ 只能用在方法中，方法中访问成员变量之前默认有个this.

   this的用法：

   • this.成员变量名-------------访问成员变量

     class Student {
         String name; //成员变量(整个类中)
         int age;
         String address;
         //局部变量(当前方法中)
         Student(String name,int age,String address){
             this.name = name;
             this.age = age;
             this.address = address;
         }
     
         void study(){
             System.out.println(name+"在学习...");
         }
         void sayHi(){                       
             System.out.println("大家好，我叫"+name+"，今
                                年"+age+"岁了，家住"+address);
             }
         }
     

   • this.方法名()-----------------调用方法(了解)

   • this()---------------------------调用构造方法(了解)

3. null：表示空，没有指向任何对象，若引用的值为null，则该引用不能进行任何点操作了，若操作则发生NullPointerException空指针异常

4. null和NullPointerException
   

5. 引用类型数组：

   1)Bomb[] bs = new Bomb[3];
     bs[0] = new Bomb(100,200); //1)给元素赋值需要去new个对象
     bs[1] = new Bomb(200,300);
     bs[2] = new Bomb(220,330);
     //2)若想访问对象的数据，需要通过数组元素去打点
     bs[0].x = 111; //给第1个炸弹的x修改为111  
     System.out.println(bs[1].width); //输出第2个炸弹的宽
     bs[2].move(); //第3个炸弹移动
   

引用类型数组图

  引用类型与基本类型内存图

补充：

1. 成员变量：写在类中，方法外--------有默认值

   局部变量：方法中------------------------没有默认值

2. java规定：成员变量和局部变量是可以同名的

   • 使用的时候默认采取的是就近原则

3. 内存管理：由JVM来管理的

   • 堆：new出来的对象(包括成员变量)
   • 栈：局部变量(包括方法的参数)
   • 方法区：-----------周四讲

4. 数组也是一个对象，所以数组对象也存储在堆中，

   将数组的元素当作成员变量一并存储在堆中

面向对象第三天：

潜艇游戏第一天：

1. 设计6个类，设计World类并测试

潜艇游戏第二天：

1. 给6个类添加构造方法，并测试

潜艇游戏第三天：

1. 设计侦察潜艇数组、鱼雷潜艇数组、水雷潜艇数组、水雷数组、炸弹数组，并测试
2. 设计SeaObject超类，6个类继承SeaObject
3. 给SeaObject设计两个构造方法，6个派生类分别调用
4. 将侦察潜艇数组、鱼雷潜艇数组、水雷潜艇数组统一组合为SeaObject数组，并测试

回顾：

1. 构造方法：构造函数、构造器、构建器--------复用给成员变量赋值

   • 作用：给成员变量赋初值
   • 与类同名，没有返回值类型(连void)
   • 创建对象时被自动调用
   • 若自己不写构造，默认一个无参构造，若自己写了构造，则不再默认提供
   • 可以重载

2. this：指代当前对象，哪个对象调用方法它指的就是哪个对象

   this的用法：

   this.成员变量名-------------------------访问成员变量

3. null：表示空，没有指向任何对象

   ​ 若引用的值为null，则该引用不能进行任何操作了，若操作则发生 NullPointerException空指针异常

4. 引用类型数组：

   Bomb[] bs = new Bomb[3];
   bs[0] = new Bomb(100,200); //1)new
   bs[1] = new Bomb(200,300);
   bs[2] = new Bomb(300,400);
   System.out.println(bs[0].width); //2)访问属性需打点
   

笔记：

1. 引用类型数组：

   1)Bomb[] bs = new Bomb[3];
     bs[0] = new Bomb(100,200);
     bs[1] = new Bomb(200,300);
     bs[2] = new Bomb(300,400);
     System.out.println(bs[0].width); //输出第1个炸弹的宽
     bs[1].x = 250; //修改第2个炸弹的x为250
     bs[2].move(); //第3个炸弹移动
     
     for(int i=0;i<bs.length;i++){ //遍历所有子弹
         System.out.println(bs[i].height); //输出每个子弹的高
         bs[i].move(); //每个子弹移动
     }
   2)Bomb[] bs = new Bomb[]{ //了解
         new Bomb(100,200),
         new Bomb(200,300),
         new Bomb(300,400)
     };
   

2. 继承：

   • 作用：代码复用

   • 通过extends来实现继承

   • 超类/父类：共有的属性和行为

     派生类/子类：特有的属性和行为

   • 派生类既能访问自己的，也能访问超类的，但超类不能访问派生类的

   • 一个超类可以有多个派生类

     一个派生类只能有一个超类-----------单一继承

   • 具有传递性

   • java规定：构造派生类之前必须先构造超类

     • 派生类的构造方法中若没有调用超类的构造方法，则默认super()调用超类的无参构造方法
     • 派生类的构造方法中若自己调用了超类的构造方法，则不再默认提供

     //super的演示
     public class SuperDemo {
         public static void main(String[] args) {
             Boo o = new Boo();
         }
     }
     class Coo{
         Coo(int a){
         }
     }
     class Doo extends Coo{
         Doo(){
             super(5); //调用超类的有参构造
         }
         /*
         //如下代码为默认的:
         Doo(){
             super();
         }
          */
     }
     
     class Aoo{
         Aoo(){
             System.out.println("超类构造");
         }
     }
     class Boo extends Aoo{
         Boo(){
             //super(); //默认的，调用超类的无参构造
             System.out.println("派生类构造");
         }
     }
     

3. super：指代当前对象的超类对象

   super的用法：

   • super.成员变量名----------------------访问超类的成员变量(了解)
   • super.方法名()---------------------------调用超类的方法----------明天讲
   • super()-------------------------------------调用超类的构造方法

4. 向上造型：---------------------代码复用

   • 超类型的引用指向了派生类的对象
   • 能点出来什么，看引用的类型-----------这是规定，记住就OK了

   package ooday03;
   //向上造型的演示
   public class UploadDemo {
       public static void main(String[] args) {
           Eoo o1 = new Eoo();
           o1.a = 1;
           o1.show();
           //o1.b = 2;  //编译错误
           //o1.test(); //编译错误，超类不能访问派生类的
   
           Foo o2 = new Foo();
           o2.b = 1;
           o2.test();
           o2.a = 2;  //正确
           o2.show(); //正确，派生类可以访问超类的
   
           Eoo o3 = new Foo(); //向上造型
           o3.a = 1;
           o3.show();
           //o3.b = 2;  //编译错误
           //o3.test(); //编译错误，能点出来什么，看引用的类型
       }
   }
   
   class Eoo{
       int a;
       void show(){
       }
   }
   class Foo extends Eoo{
       int b;
       void test(){
       }
   }
   

精华笔记：

1. 引用类型数组：

2. 继承：

   • 作用：代码复用

   • 通过extends来实现继承

   • 超类/父类：共有的属性和行为

     派生类/子类：特有的属性和行为

   • 派生类既能访问自己的，也能访问超类的，但超类不能访问派生类的

   • 一个超类可以有多个派生类

     一个派生类只能有一个超类-----------单一继承

   • 具有传递性

   • java规定：构造派生类之前必须先构造超类

     • 派生类的构造方法中若没有调用超类的构造方法，则默认super()调用超类的无参构造方法
     • 派生类的构造方法中若自己调用了超类的构造方法，则不再默认提供

3. super：指代当前对象的超类对象

   super的用法：

   • super.成员变量名----------------------访问超类的成员变量(了解)
   • super.方法名()---------------------------调用超类的方法----------明天讲
   • super()-------------------------------------调用超类的构造方法

4. 向上造型：---------------------代码复用

   • 超类型的引用指向了派生类的对象
   • 能点出来什么，看引用的类型-----------这是规定，记住就OK了

补充：

1. 继承意味着代码虽然我没有写，但也属于我，只是没有写在一起而已
2. 泛化：将共有的抽出来的过程，泛化是设计层面的概念，从代码实现层面来说咱们就是继承，泛化就是继承
3. 继承要符合is a(是一个)的关系

面向对象第四天：

潜艇游戏第一天：

1. 设计6个类，设计World类并测试

潜艇游戏第二天：

1. 给6个类添加构造方法，并测试

潜艇游戏第三天：

1. 设计SeaObject超类，6个类继承SeaObject
2. 给SeaObject设计两个构造方法，6个派生类分别调用
3. 设计潜艇数组、水雷数组、深水炸弹数组，并测试

潜艇游戏第四天：

1. 在6个类中重写move()移动
2. 给类中成员添加访问控制修饰符
3. 设计Images图片类

回顾：

1. 引用类型数组：

   Bomb[] bs = new Bomb[3];
   ...
   for(int i=0;i<bs.length;i++){
       System.out.println(bs[i].x+","+bs[i].y);
       bs[i].move();
   }
   

2. 继承：

   ​ 代码复用，extends

   ​ 超类：共有的 派生类：特有的

   ​ 派生类可以访问派生类自己的+超类的，超类只能访问超类自己的

   ​ 单一继承，传递性

   ​ 构造派生类之前必须先构造超类

   ​ -----super()调用构造方法必须位于派生类构造方法的第一行

   ​ 派生类构造中若自己不调超类构造，则默认super()调超类无参构造

   ​ 若自己调用了，则不再默认提供

3. super：指代当前对象的超类对象

   super.成员变量名---------------------------访问超类的成员变量

   super.方法名()-------------------------------调用超类的方法--------一会讲

   super()-----------------------------------------调用超类的构造方法

4. 向上造型：-------------------------------------提高复用性

   • 超类型的引用指向派生类的对象
   • 能点出来什么，是看引用的类型

笔记：

1. 方法的重写(override/overriding)：重新写、覆盖

   • 发生在父子类中，方法名相同，参数列表相同
   • 重写方法被调用时，看对象的类型------------这是规定，记住就OK

   我继承了一个中餐馆
   class Aoo{
       void do(){
           做中餐
       }
   }
   A:我还是想做中餐------------不需要重写
       class Boo extends Aoo{
       }
   B:我想改做西餐--------------需要重写
       class Boo extends Aoo{
           void do(){
           	做西餐
       	}
       }
   C:我想在中餐基础之上加西餐-----需要重写(先super中餐，再加入西餐)
       class Boo extends Aoo{
           void do(){
           	super.do();
               做西餐
       	}
       }
   

2. 重写与重载的区别：重点(常见的面试题)

   • 重写：发生在父子类中，方法名相同，参数列表相同

   • 重载：发生在同一类中，方法名相同，参数列表不同

3. package和import：

   • package：声明包

     • 作用：避免类的命名冲突
     • 同包中的类不能同名，不同包中的类可以同名
     • 类的全称：包名.类名，包名常常有层次结构
     • 建议：包名所有字母都小写

   • import：导入类

     • 同包中的类可以直接访问，不同包的类不能直接访问，若想访问：
       • 先import导入类，再访问类----------建议
       • 类的全称-----------------------------------太繁琐，不建议

4. 访问控制修饰符：

   • public：公开的，任何类
   • private：私有的，本类
   • protected：受保护的，本类、派生类、同包类
   • 默认的：什么也不写，本类、同包类

   //封装的意义
   class Card{
       private String cardId;
       private String cardPwd;
       private double balance;
       
       public boolean payMoney(double money){ //支付金额
           if(balance>=money){
               balance-=money;
               return true;
           }else{
               return false;
           }
       }
       
       public boolean checkPwd(String pwd){ //检测密码
           if(pwd与cardPwd相同){
               return true;
           }else{
               return false;
           }
       }
   }
   

   //访问权限范围:
   package ooday04;
   //演示访问控制修饰符
   public class Aoo {
       public int a;     //任何类
       protected int b;  //本类、派生类、同包类
       int c;            //本类、同包类
       private int d;    //本类
   
       void show(){
           a = 1;
           b = 2;
           c = 3;
           d = 4;
       }
   }
   
   class Boo{ //---------------演示private
       void show(){
           Aoo o = new Aoo();
           o.a = 1;
           o.b = 2;
           o.c = 3;
           //o.d = 4; //编译错误
       }
   }
   
   package ooday04_vis;
   import ooday04.Aoo;
   public class Coo { //演示同包的概念
       void show(){
           Aoo o = new Aoo();
           o.a = 1;
           //o.b = 2; //编译错误
           //o.c = 3; //编译错误
           //o.d = 4; //编译错误
       }
   }
   
   class Doo extends Aoo{ //演示protected
       void show(){
           a = 1;
           b = 2;
           //c = 3; //编译错误
           //d = 4; //编译错误
       }
   }
   

5. static：静态的

   • 静态变量：

     • 由static修饰
     • 属于类，存储在方法区中，只有一份
     • 常常通过类名点来访问
     • 何时用：所有对象所共享的数据(图片、音频、视频等)

     public class StaticDemo {
         public static void main(String[] args) {
             Eoo o1 = new Eoo();
             o1.show();
             Eoo o2 = new Eoo();
             o2.show();
             Eoo o3 = new Eoo();
             o3.show();
             System.out.println(Eoo.b); //常常通过类名点来访问
         }
     }
     
     class Eoo{ //演示静态变量
         int a;
         static int b;
         Eoo(){
             a++;
             b++;
         }
         void show(){
             System.out.println("a="+a+",b="+b);
         }
     }
     

   • 静态方法：

     • 由static修饰
     • 属于类，存储在方法区中，只有一份
     • 常常通过类名点来访问
     • 静态方法没有隐式this传递，所以不能直接访问实例成员
     • 何时用：方法的操作与对象无关

     //static的演示
     public class StaticDemo {
         public static void main(String[] args) {
             Goo.plus(4,6);
         }
     }
     
     //演示静态方法
     class Foo{
         int a; //实例变量(由对象来访问)
         static int b; //静态变量(由类名来访问)
     
         void show(){ //有隐式this
             System.out.println(this.a);
             System.out.println(Foo.b);
         }
         static void test(){
             //静态方法中没有隐式this传递
             //没有this就意味着没有对象
             //而实例变量a是必须由对象来访问的
             //所以下面的语句发生编译错误
             //System.out.println(a); //编译错误
     
             System.out.println(Eoo.b);
         }
     }
     
     //演示静态方法何时用
     class Goo{
         int a; //对象的属性
         //方法中用到了对象的属性a，意味着show()的操作与对象是有关的，不能做成静态方法
         void show(){
             System.out.println(a);
         }
         //方法中没有用到对象的属性和行为，意味着plus()的操作与对象是无关的，可以做成静态方法
         static void plus(int num1,int num2){
             int num = num1+num2;
             System.out.println(num);
         }
     }
     

   • 静态块：

     • 由static修饰
     • 属于类，在类被加载期间自动执行，一个类只被加载一次，所以静态块也只执行一次
     • 何时用：初始化/加载静态资源(图片、音频、视频等)

     public class StaticDemo {
         public static void main(String[] args) {
             Hoo o4 = new Hoo();
             Hoo o5 = new Hoo();
             Hoo o6 = new Hoo();
         }
     }
     //演示静态块
     class Hoo{
         static {
             System.out.println("静态块");
         }
         Hoo(){
             System.out.println("构造方法");
         }
     }
     

精华笔记

1. 方法的重写(override/overriding)：重新写、覆盖

   • 发生在父子类中，方法名相同，参数列表相同
   • 重写方法被调用时，看对象的类型------------这是规定，记住就OK

2. 重写与重载的区别：重点(常见的面试题)

   • 重写：发生在父子类中，方法名相同，参数列表相同

   • 重载：发生在同一类中，方法名相同，参数列表不同

3. package和import：

   • package：声明包

     • 作用：避免类的命名冲突
     • 同包中的类不能同名，不同包中的类可以同名
     • 类的全称：包名.类名，包名常常有层次结构
     • 建议：包名所有字母都小写

   • import：导入类

     • 同包中的类可以直接访问，不同包的类不能直接访问，若想访问：
       • 先import导入类，再访问类----------建议
       • 类的全称-----------------------------------太繁琐，不建议

4. 访问控制修饰符：

   • public：公开的，任何类
   • private：私有的，本类
   • protected：受保护的，本类、派生类、同包类
   • 默认的：什么也不写，本类、同包类

5. static：静态的

   • 静态变量：
     • 由static修饰
     • 属于类，存储在方法区中，只有一份
     • 常常通过类名点来访问
     • 何时用：所有对象所共享的数据(图片、音频、视频等)
   • 静态方法：
     • 由static修饰
     • 属于类，存储在方法区中，只有一份
     • 常常通过类名点来访问
     • 静态方法没有隐式this传递，所以不能直接访问实例成员
     • 何时用：方法的操作与对象无关
   • 静态块：
     • 由static修饰
     • 属于类，在类被加载期间自动执行，一个类只被加载一次，所以静态块也只执行一次
     • 何时用：初始化/加载静态资源(图片、音频、视频等)

补充：

1. 成员变量分两种：

   • 实例变量：没有static修饰，属于对象的，存储在堆中，

     ​ 有几个对象就有几份，通过引用打点来访问

   • 静态变量：有static修饰，属于类的，存储在方法区中，

     ​ 只有一份，通过类名打点来访问

2. 内存管理：由JVM来管理的

   • 堆：new出来的对象(包括成员变量)
   • 栈：局部变量(包括方法的参数)
   • 方法区：.class字节码文件(包括静态变量、所有方法)

3. 在构造方法中给实例变量做初始化

   在静态块中给静态变量做初始化

潜艇游戏第五天：

潜艇游戏第一天：

1. 设计6个类，设计World类并测试

潜艇游戏第二天：

1. 给6个类添加构造方法，并测试

潜艇游戏第三天：

1. 设计SeaObject超类，6个类继承SeaObject
2. 给SeaObject设计两个构造方法，6个派生类分别调用
3. 设计潜艇数组、水雷数组、深水炸弹数组，并测试

潜艇游戏第四天：

1. 在6个类中重写move()移动
2. 给类中成员添加访问控制修饰符
3. 设计Images图片类

潜艇游戏第五天：

1. 将窗口的宽和高设计为常量，适当地方做修改

2. 画窗口：在World类中—共3步，不要求掌握，Ctrl C/V

   • import JFrame和JPanel
   • 设计World类继承JPanel
   • CV大法

3. 画海洋图、画对象

   1)想画对象需要去获取对象的图片，每个对象都能获取图片，
     意味着获取图片行为为共有的行为，所以设计在SeaObject中，
     每个对象获取图片的行为都是不一样的，所以设计为抽象方法
     ----在SeaObject中设计getImage()获取对象的图片
   2)在6个派生类中重写getImage()获取对象的图片
     ----重写getImage()
   3)因为只有活着的对象才需要画到窗口中，所以需要设计对象的状态，
     每个对象都有状态，意味着状态为共有属性，所以设计在SeaObject中，
     状态一般设计为常量，同时设计state变量表示当前状态
     ----在SeaObject中设计LIVE、DEAD常量，state变量表示当前状态
     后期的业务中还需要判断状态，每个对象都得判断状态，
     意味着判断状态行为为共有的行为，所以设计在SeaObject中，
     每个对象判断状态的行为都是一样的，所以设计为普通方法
     ----在SeaObject中设计isLive()、isDead()判断对象的状态
   4)数据都有了就可以开画了，每个对象都能画，
     意味着画对象的行为为共有行为，所以设计在SeaObject中，
     每个对象画的行为都是一样的，所以设计为普通方法
     ----在SeaObject中设计paintImage()画对象
   5)画对象的行为做好了，在窗口World中调用即可:
     5.1)准备对象
     5.2)重写paint()画方法
   

回顾：

1. 方法的重写(override)：重新写、覆盖

   • 发生在父子类中，方法名相同，参数列表相同
   • 重写方法被调用时，看对象的类型

2. 重写与重载的区别：

   • 重写：发生在父子类中，方法名相同，参数列表相同
   • 重载：发生在同一类中，方法名相同，参数列表不同

3. package和import：

4. 访问控制修饰符：实现封装，暴露与隐藏-----保护数据的安全

   • public：公开的，任何类
   • protected：受保护的，本类、派生类、同包类
   • 默认的：什么也不写，本类、同包类----------------java不建议
   • private：私有的，本类

5. static：静态的

   • 静态变量：static，属于类，方法区，一份，类名点来访问

     ​ 所有对象所共享的数据(图片、音频、视频等)

   • 静态方法：static，属于类，方法区，一份，类名点来访问

     ​ 静态方法没有隐式this传递，不能直接访问实例成员

     ​ 方法的操作与对象无关

   • 静态块：static，属于类，在类被加载期间自动执行，一次

     ​ 初始化/加载静态资源(图片、音频、视频等)

笔记：

1. final：最终的，不可改变的-----------单独应用几率低

   • 修饰变量：变量不能被改变

     //演示final修饰变量
     class Aoo{
         final int num = 5;
         void show(){
             //num = 55; //编译错误，final的变量不能被改变
         }
     }
     

   • 修饰方法：方法不能被重写

     //演示final修饰方法
     class Boo{
         final void show(){}
     }
     class Coo extends Boo{
         //void show(){} //编译错误，final修饰的方法不能被重写
     }
     

   • 修饰类：类不能被继承

     //演示final修饰类
     final class Doo{}
     //class Eoo extends Doo{} //编译错误，final的类不能被继承
     class Foo{}
     final class Goo extends Foo{} //不能当老爸，但能当儿子
     

2. static final常量：应用率高

   • 必须声明同时初始化
   • 通过类名点来访问，不能被改变
   • 建议：常量名所有字母都大写，多个单词用_分隔
   • 编译器在编译时会将常量直接替换为具体的值，效率高
   • 何时用：数据永远不变，并且经常使用

   public class StaticFinalDemo {
       public static void main(String[] args) {
           System.out.println(Hoo.PI); //通过类名点来访问
           //Hoo.PI = 3.1415926; //编译错误，常量不能被改变
   
           //1)加载Ioo.class到方法区中
           //2)将静态变量num一并存储到方法区中
           //3)到方法区中获取num的值并输出
           System.out.println(Ioo.num);
   
           //编译器在编译时将常量直接替换为具体的值，效率高
           //相当于System.out.println(5);
           System.out.println(Ioo.COUNT);
       }
   }
   
   class Ioo{
       public static int num = 5; //静态变量
       public static final int COUNT = 5; //常量
   }
   
   class Hoo{
       public static final double PI = 3.14159;
       //public static final int NUM; //编译错误，常量必须声明同时初始化
   }
   

3. 抽象方法：

   • 由abstract修饰
   • 只有方法的定义，没有具体的实现(连{}都没有)

4. 抽象类：

   • 由abstract修饰

   • 包含抽象方法的类必须是抽象类

   • 抽象类不能被实例化(new对象)

   • 抽象类是需要被继承的，派生类：

     • 重写所有抽象方法--------------变不完整为完整
     • 也声明为抽象类------------------一般不这么做

   • 抽象类的意义：

     • 封装共有的属性和行为--------------------代码复用

     • 为所有派生类提供统一的类型-----------向上造型—代码复用

     • 可以包含抽象方法，为所有派生类提供统一的入口(能点出来)

       派生类的行为不同，但入口是一致的，同时相当于定义了一个标准

精华笔记：

1. final：最终的，不可改变的-----------单独应用几率低

   • 修饰变量：变量不能被改变
   • 修饰方法：方法不能被重写
   • 修饰类：类不能被继承

2. static final常量：应用率高

   • 必须声明同时初始化
   • 通过类名点来访问，不能被改变
   • 建议：常量名所有字母都大写，多个单词用_分隔
   • 编译器在编译时会将常量直接替换为具体的值，效率高
   • 何时用：数据永远不变，并且经常使用

3. 抽象方法：

   • 由abstract修饰
   • 只有方法的定义，没有具体的实现(连{}都没有)

4. 抽象类：

   • 由abstract修饰

   • 包含抽象方法的类必须是抽象类

     不包含抽象方法的类也可以声明为抽象类-------------了解

   • 抽象类不能被实例化(new对象)

   • 抽象类是需要被继承的，派生类：

     • 重写所有抽象方法--------------变不完整为完整
     • 也声明为抽象类------------------一般不这么做

   • 抽象类的意义：

     • 封装共有的属性和行为--------------------代码复用

     • 为所有派生类提供统一的类型-----------向上造型—代码复用

     • 可以包含抽象方法，为所有派生类提供统一的入口(能点出来)

       派生类的行为不同，但入口是一致的，同时相当于定义了一个标准

补充：

1. 设计规则：

   • 将派生类所共有的属性和行为，抽到超类中-------------抽共性

   • 派生类的行为都一样，则设计为普通方法

     派生类的行为不一样，则设计为抽象方法

   • ------------下周二讲

2. 抽象方法/抽象类的疑问:

   • 抽象方法的存在意义是什么？

     • 保证当发生向上造型时，通过超类型的引用能点出来那个方法

   • 既然意义只在于能点出来，那为什么不设计为普通方法？

     • 若设计为普通方法，则派生类可以重写也可以不重写，而设计为抽象方法，可以强制派生类必须重写------做了个标准，强制必须重写

面向对象第六天：

潜艇游戏第一天：

1. 设计6个类，设计World类并测试

潜艇游戏第二天：

1. 给6个类添加构造方法，并测试

潜艇游戏第三天：

1. 设计SeaObject超类，6个类继承SeaObject
2. 给SeaObject设计两个构造方法，6个派生类分别调用
3. 设计潜艇数组、水雷数组、深水炸弹数组，并测试

潜艇游戏第四天：

1. 在6个类中重写move()移动
2. 给类中成员添加访问控制修饰符
3. 设计Images图片类

潜艇游戏第五天：

1. 将窗口的宽和高设计为常量，适当地方做修改

2. 画窗口：在World类中—共3步，不要求掌握，Ctrl C/V

   • import JFrame和JPanel
   • 设计World类继承JPanel
   • CV大法

3. 画海洋图、画对象

   1)想画对象需要去获取对象的图片，每个对象都能获取图片，
     意味着获取图片行为为共有的行为，所以设计在SeaObject中，
     每个对象获取图片的行为都是不一样的，所以设计为抽象方法
     ----在SeaObject中设计getImage()获取对象的图片
   2)在6个派生类中重写getImage()获取对象的图片
     ----重写getImage()
   3)因为只有活着的对象才需要画到窗口中，所以需要设计对象的状态，
     每个对象都有状态，意味着状态为共有属性，所以设计在SeaObject中，
     状态一般设计为常量，同时设计state变量表示当前状态
     ----在SeaObject中设计LIVE、DEAD常量，state变量表示当前状态
     后期的业务中还需要判断状态，每个对象都得判断状态，
     意味着判断状态行为为共有的行为，所以设计在SeaObject中，
     每个对象判断状态的行为都是一样的，所以设计为普通方法
     ----在SeaObject中设计isLive()、isDead()判断对象的状态
   4)数据都有了就可以开画了，每个对象都能画，
     意味着画对象的行为为共有行为，所以设计在SeaObject中，
     每个对象画的行为都是一样的，所以设计为普通方法
     ----在SeaObject中设计paintImage()画对象
   5)画对象的行为做好了，在窗口World中调用即可:
     5.1)准备对象
     5.2)重写paint()画方法  
   

潜艇游戏第六天：

1. 潜艇入场：

   • 潜艇对象是由窗口产生的，所以在World类中设计nextSubmarine()生成潜艇对象

   • 潜艇入场为定时发生的，所以在run()中调用submarineEnterAction()实现潜艇入场

     在submarineEnterAction()中：

     ​ 每400毫秒，获取潜艇对象obj，submarines扩容，将obj装到末尾

2. 水雷入场：

   • 水雷是由水雷潜艇发射出来的，所以在MineSubmarine中shootMine()生成水雷对象

   • 水雷入场为定时发生的，所以在run()中调用mineEnterAction()实现水雷入场

     在mineEnterAction()中：

     ​ 每1秒钟，…(暂时搁置，周三时讲)

3. 海洋对象移动：

   • 海洋对象移动为共有的行为，所以在SeaObject中设计抽象方法move()实现海洋对象移动，在派生类重写move()

   • 海洋对象移动为定时发生的，所以在run()中调用moveAction()实现海洋对象移动

     在moveAction()中：

     ​ 遍历所有潜艇潜艇move()，遍历所有水雷水雷move()，遍历所有深水炸弹深水炸弹move()

     ​

回顾：

1. final：最终的，不可改变的

   ​ 变量不能被改变、方法不能被重写、类不能被继承

2. static final常量：

   ​ 必须声明同时初始化，由类名点来访问，不能被改变，大写

   ​ 编译器在编译时会将常量直接替换为具体的值，效率高

   ​ 数据永远不变，并且经常使用

3. 抽象方法：

   ​ abstract，只有方法的定义，没有具体的实现(连{}都没有)

4. 抽象类：

   ​ abstract，包含抽象方法的类必须是抽象类，不能被实例化

   ​ 需要被继承，派生类：必须重写所有抽象方法----变不完整为完整

   ​ 意义：代码复用、向上造型、可以包含抽象方法，为所有派生类提供统一的入口(能点出来)，强制必须重写(制定了一个标准)

笔记：

1. 成员内部类：应用率低，了解

   • 类中套类，外面的称为外部类，里面的称为内部类
   • 内部类通常只服务于外部类，对外不具备可见性
   • 内部类对象只能在外部类中创建
   • 内部类中可以直接访问外部类的成员(包括私有的)，在内部类中有个隐式的引用指向了创建它的外部类对象------外部类名.this

   public class InnerClassDemo {
       public static void main(String[] args) {
           Mama m = new Mama();
           //Baby b = new Baby(); //编译错误，内部类对外不具备可见性
       }
   }
   
   class Mama{ //外部类
       private String name;
       Baby b = new Baby(); //内部类对象通常在外部类中创建
       class Baby{ //内部类
           void show(){
               System.out.println(name);
               System.out.println(Mama.this.name); //Mama.this指代它的外部类对象
           }
       }
   }
   

2. 匿名内部类：应用率高-----------------大大简化代码

   • 若想创建一个类(派生类)的对象，并且对象只创建一个，此时该类不必命名，称为匿名内部类
   • 匿名内部类中不能修改外面变量的值，因为在此处该变量默认为final的

   public class AnonInnerClassDemo {
       public static void main(String[] args) {
           //1)创建了Aoo的一个派生类，但是没有名字
           //2)为该派生类创建了一个对象，名为o1
           //3)大括号中的为派生类的类体
           Aoo o1 = new Aoo(){
           };
   
           //1)创建了Aoo的一个派生类，但是没有名字
           //2)为该派生类创建了一个对象，名为o2
           //3)大括号中的为派生类的类体
           Aoo o2 = new Aoo(){
           };
   
   
           int num = 5;
           num = 55;
           //1)创建了Boo的一个派生类，但是没有名字
           //2)为该派生类创建了一个对象，名为o3
           //3)大括号中的为派生类的类体
           Boo o3 = new Boo(){
               void show(){
                   System.out.println("showshow");
                   //num = 66; //编译错误，匿名内部类中不能修饰外面变量的值，因为在此处默认为final的
               }
           };
           o3.show();
       }
   }
   
   abstract class Boo{
       abstract void show();
   }
   
   abstract class Aoo{
   }
   

精华笔记:

1. 成员内部类：应用率低，了解

   • 类中套类，外面的称为外部类，里面的称为内部类
   • 内部类通常只服务于外部类，对外不具备可见性
   • 内部类对象只能在外部类中创建
   • 内部类中可以直接访问外部类的成员(包括私有的)，在内部类中有个隐式的引用指向了创建它的外部类对象------外部类名.this

2. 匿名内部类：应用率高-----------------大大简化代码

   • 若想创建一个类(派生类)的对象，并且对象只创建一个，此时该类不必命名，称为匿名内部类
   • 匿名内部类中不能修改外面变量的值，因为在此处该变量默认为final的

补充：

1. 隐式对象：

   • this：当前对象
   • super：当前对象的超类对象
   • 外部类名.this：当前对象的外部类对象

2. 必须记住的，API中会用的：

   • 外部类名.this：指代当前对象的外部类对象
   • 匿名内部类不能修改外面变量的值，因为在此处默认为final的

3. 小面试题：

   • 问：内部类有独立的.class字节码文件吗？

     答：有

4. 做功能的套路：

   • 先写行为/方法：
     • 若为某对象所特有的行为，就将方法设计在特定的类中
     • 若为所有对象所共有的行为，就将方法设计在超类中
   • 窗口调用：
     • 若为定时发生的，就在定时器中调用
     • 若为事件触发的，就在侦听器中调用----------明天上午讲

5. 调错方式：

   • 打桩：System.out.println(数据);

面向对象第七天：

潜艇游戏第一天：

1. 设计6个类，设计World类并测试

潜艇游戏第二天：

1. 给6个类添加构造方法，并测试

潜艇游戏第三天：

1. 设计SeaObject超类，6个类继承SeaObject
2. 给SeaObject设计两个构造方法，6个派生类分别调用
3. 设计潜艇数组、水雷数组、深水炸弹数组，并测试

潜艇游戏第四天：

1. 在6个类中重写move()移动
2. 给类中成员添加访问控制修饰符
3. 设计Images图片类

潜艇游戏第五天：

1. 将窗口的宽和高设计为常量，适当地方做修改

2. 画窗口：在World类中—共3步，不要求掌握，Ctrl C/V

   • import JFrame和JPanel
   • 设计World类继承JPanel
   • CV大法

3. 画海洋图、画对象

   1)想画对象需要去获取对象的图片，每个对象都能获取图片，
     意味着获取图片行为为共有的行为，所以设计在SeaObject中，
     每个对象获取图片的行为都是不一样的，所以设计为抽象方法
     ----在SeaObject中设计getImage()获取对象的图片
   2)在6个派生类中重写getImage()获取对象的图片
     ----重写getImage()
   3)因为只有活着的对象才需要画到窗口中，所以需要设计对象的状态，
     每个对象都有状态，意味着状态为共有属性，所以设计在SeaObject中，
     状态一般设计为常量，同时设计state变量表示当前状态
     ----在SeaObject中设计LIVE、DEAD常量，state变量表示当前状态
     后期的业务中还需要判断状态，每个对象都得判断状态，
     意味着判断状态行为为共有的行为，所以设计在SeaObject中，
     每个对象判断状态的行为都是一样的，所以设计为普通方法
     ----在SeaObject中设计isLive()、isDead()判断对象的状态
   4)数据都有了就可以开画了，每个对象都能画，
     意味着画对象的行为为共有行为，所以设计在SeaObject中，
     每个对象画的行为都是一样的，所以设计为普通方法
     ----在SeaObject中设计paintImage()画对象
   5)画对象的行为做好了，在窗口World中调用即可:
     5.1)准备对象
     5.2)重写paint()画方法