Java基础篇

FOUNDATION01
Unit01—JAVA环境搭建和运行原理
1.什么是JAVA编程语言？
编程语言就是人类与计算机沟通的桥梁，JAVA语言只是编程语言中的一种，我们使用编程语言就可以操作计算机。
一、环境搭建配置
1.下载JDK方式：达内开发文档服务器 (canglaoshi.org)
WindowX64
image-20211009200938453

MAC:
image-20210903171057056

JDK下载方式二：https://www.oracle.com/index.html通过官网进行下载JDK

image-20210903165250051
image-20210903165430675
image-202110092021106303.根据自己的操作系统下载解压后安装非常简单，一直下一步就好，默认装C盘的位置要记一下哈，接下来配置JAVA环境变量时需要！
4.配置环境变量的视频链接：http://doc.canglaoshi.org/doc/windows_jdk_eclipse.html
image-20210903171856897

5.安装IEDA编辑器安装配置链接：http://doc.canglaoshi.org/doc/idea_install_202010/20201019-IDEA-1-INSTALL.html
IDEA官网下载链接：https://www.jetbrains.com/idea/
二、运行原理
我们通常写的类文件保存后，系统会生成一个同名的.class文件，该文件是转换后可以交给计算机处理的二进制文件，是通过JVM（虚拟机）根据不同的平台对应生成。如果将.class文件删除的话运行可能会出出现报错信（无法加载主类…）
image-20210903174323389

//为什么要建包，就是为了区分同名的类文件。因为一个包中是不能存在重名的类文件。
//代表当前是cn.tedu.day01包文件夹
package cn.tedu.day01;

//注意事项 Unit01Test是JAVA类文件
//我们所有的代码都应该存放在类文件中，否则会报错！
public class Unit01Test {

//方法（功能工具的意思）
//代表程序的主入口（程序会从当前的方法中进行执行）
//快捷键：格式化代码 Ctrl+Alt+L
//代码是顺序执行的！逐语句执行
public static void main(String[] args)
{
//十进制—123456789 10 11 12 13
//二进制—01 10
//在控制台当中打印信息的方法
System.out.println(3);
System.out.println(2);
//sout代表打印信息方法的快捷方式
System.out.println(1);
}

}
Unit01总结：
image-20211010105521623

Unit02—创建GUI应用和变量
1.GUI的简介：GUI直译是图形用户界面。我们现阶段使用达内提供的GUI应用包，来进行我们当前GUI界面的搭建。
package cn.tedu.day02;

import cn.tedu.util.App;

import java.awt.;

/

类文件的注释：（知道当前这个类文件里面的代码主要在做什么！）
当前脚本主要用来测试GUI界面生成的代码逻辑
*/
public class Unit01Test extends App {

//main ：程序主入口所有程序执行的入口
public static void main(String[] args)
{
//开启GUI的绘制语法
Unit01Test u =new Unit01Test();
//开启
u.start();
}
//提供绘制的功能快捷方式 painting
//g代表就是画笔
public void painting(Graphics2D g)
{
//g.setColor(new Color(255,0,0));
g.fillOval(1,1,50,50);
//r g b
//g.setColor(new Color(0,0,255));
//在编码过程中切记一定要把自己的输入法切换为英文状态！
// g.drawString(“hello JAVA!”,90,20);
}

}
2.变量
1.什么是变量：变量来源于数学，是计算机语言中用来存储计算数据、存储计算结果的一种存储结构
2.为什么要用变量：当我们需要讲数据存储到内存中时，那么就需要变量来进行存储。
3.变量名的约束：JAVA是强类型语言，变量有严格的语法约定，所以在使用变量时需要遵守以下规范：
image-20211010164851009

package cn.tedu.day02;

public class Unit02Test {

public static void main(String[] args) {
//可以理解为number就是一个兜子前面的int类型代表的就是兜子大小
// 里面放了数据10
int number = 10;
//将数据100的这个数值赋值给了number（兜子）
//那么会将number(兜子)之前存在的数据进行覆盖
number = 100;
//再输出时打印的则是覆盖后的数据
//System.out.println(number);//100
//-----------------------------
int number2 =10;
//number2+100，就是将number2的数据取出来跟100做相加
//再赋值给number2
//先计算右边的内容再进行赋啊啊值给左边的操作！
number2 = number2+100;
System.out.println(number2);
//-----------------------------
//！JAVA是强类型的语言，所以语法来讲比较严格；
// number3 =20;报错声明变量需确定类型
//int number3 =“abc”;变量类型与数据类型不匹配
//int number3;
//System.out.println(number3);未经初始化赋值的变量不可使用
//-----------------------------
//注意：其变量名称时要见名知意
//变量的命名规则

}
}

回顾：
1.java开发环境
编译期：.生成.class源文件（字节码文件）

						运行期：JVM（虚拟机）根据平台生成并运行.class文件（0和1）。

名词：
1.JVM（虚拟机）加载并运行.class
2.JRE :Java的运行环境包含JVM和JavaAPI（小零件）
3.JDK ：开发工具包编译运行等一些命令
2.IDEA（编译器工具）
开发步骤：

                 新建一个JAVA项目
					   新建一个包 （分门别类进行存放）

					  新建JAVA类  写了第一个程序   打印输出语句

3.GUI 的创建界面搭建绘制字符串、圆形
4.变量：
作为一名程序员，我们要知道如何在内存中开辟空间，存放数据。

			    数据（数字、文字、图片、音频、视频....）

4.1 变量的命名规范！
//注意：其变量名称时要见名知意
//变量的命名规则！
//1. 只能包含数字0-9,字母a-z,和 $
int al , a1, my , 8 ; / / i n t 8 a ; 变量名不能以数字开头 / / i n t c ∗ ; 命名除了 8; //int 8a; 变量名不能以数字开头 //int c*;命名除了 8;//int8a;变量名不能以数字开头//intc∗;命名除了和_之外的符号，都不可以使用！
//2.严格区分大小写！
int aa =30;
//System.out.println(aA);aA报错，因为认为当前不存aA这个变量
//3.用变量名的时候不能使用java中的关键字（已经存在的名字）
// int class =10;

//4.允许用中文来当作变量名称，但是不建议！
//int 年龄= 18;
int age=18;//要英文的见名知意！
System.out.println(age);
//5.命名的规则：变量名称遵循小驼峰式命名规则！
//类文件的名称遵循帕斯卡命名规则！
//小驼峰：首字母小写第二个单词首字母大写！
int myAge=18;
//帕斯卡：大驼峰式首字母大写，第二个单词首字母大写！UnitTest
4.2变量的初始化
//-----------------------------
//变量的初始化
//方式一：声明+初始化
int a = 10;
//方式二：声明
int b;
//初始化
b =20;
//方式三：
int c,d,f;
c= 20;
d=30;
f=40;
4.3
实现圆形的运行方向，分别横着(沿着X)运动，竖着(沿着y)运动，可以斜着运动。
绘制了多个圆形,具体代码：

public class Unit03Test extends App {

//main 主入口方法快捷键
public static void main(String[] args)
{
Unit03Test u = new Unit03Test();
//运行当前的GUI的功能可以开始绘制了！
u.start();
}
//声明一个x的变量里面赋值为1
int x = 1;
//声明一个y的变量里面赋值为1
int y =1;
//painting 绘制方法的快捷键
// paintint 的方法被开启后会一直执行！
public void painting(Graphics2D g)
{ //以后你的薪资一定与你现在的代码量成正比！
// x = 1+1;
x= x+1;
// y = 1+1;
y=y+1;
System.out.println(x);
//g代表什么？画笔
//画笔g打点调用了fillOval 功能：绘制圆形
// 前面两个位置代表圆在画框的x 和 y位置
// 后面两个位置代表圆的宽和高
g.fillOval(x,1,80,80);
//练习：绘制第二个圆形让它沿着 y的左边往下移动
g.fillOval(1,y,80,80);
g.fillOval(x,y,80,80);
}
}

总结：

image-20211012220358982

Unit03—数据类型
JAVA中的数据类型分为两大数据类型：基本数据类型，引用类型.本章节重点介绍基本数据类型。
1.什么是基本数据类型？
JAVA中基本数据类型分为8种：byte, short,int,long,float,double,char,boolean
之前讲过变量，使用变量就是为了在内存种开辟一块地，这个地的空间大小与类型取决于
数据类型。不同类型存储不同的数据，我们在使用时选择合适的类型来进行存储数据。
2.基本数据类型中常用： int 、double 、 char 、boolean
byte（在IO(后续课程)中会用到其它地方基本不用。）
short 基本不用保留C语言中的。
float 单精度浮点用的很少保留C语言中的为了与其它语言兼容。
Long 已经很大了，通常也是很少用。
image-20211012221733981

3.我们声明变量时一定会用数据类型，那么数据类型表示在内存中开辟的空间，选择合适的数据类型会很重要（避免浪费内存）。
image-20211012222006663

1.byte（占用1字节）
byte(字节)类型是JAVA类型中最小的类型，其在内存中占用1个字节，存储的范围是-128~127。
内存中：
B(字节) KB(千字节) MB(兆字节) GB(吉字节)

 1024b 就是1KB     1024KB就是1MB 		1024MB就是1GB         1024GB就是1TB 

1.1 直接量 不能超过当前类型可存储的范围！

    //byte的使用演示： 可存储 -128 ~127
    //声明变量的语法：
    // 数据类型  变量名  = 直接量;
    byte b1 = 50;
    //byte b2 =128;编译错误，超出byte存储范围
    //byte b3 =-129;编译错误，超出byte存储范围

2.Short(占用2个字节)
JAVA中较小的数据类型，在内存占用2个字节，其存储的范围是-32768 ~32767。
short s1 =30000;
System.out.println(s1);//使用变量直接把变量名写过来就代表使用
//short s2 =32768;//编译错误，超出short存储范围
// short s3 =-32769;//编译错误，超出short存储范围
3.int(占用4个字节)
JAVA中最常用的整数类型，在内存中用4个字节,其存储的范围 -2147483648~2147483647。
存储-21亿多到21亿多范围的数字，范围广，用途大。
3.1整数的直接量默认为 int 类型，直接量不能超出范围 ,如果超出范围则编译错误。
3.2两个整数相除，结果还是整数。（注意：并不会进行四舍五入的操作）
3.3整数运算时，若超出范围则会溢出（溢出不是错误，但其结果不具实际计算意义）
//int的使用演示： -21亿多到 21亿多
int number = 2147483647;//存储了int最大值
//int number2 = 2147483648;//编译错误超出了int的存储范围
//int number2 = -2147483649;//编译错误超出了int的存储范围
int number3 = 5;
int number4 = 2;
System.out.println(number3/number4);//2 不保留小数截断。
System.out.println(number4 /number3);//0 不保留小数截断。
//System.out.println(5.0/2.0);//2.5 浮点数相除有小数！
int number5 = 2147483647;
int number6 = number5 +1;
System.out.println(number6);//结果为溢出值 —不具实际参考结果。

4.long(占用8个字节)
long类型时长整型类型，占用内存8个字节，其范围-900万万亿~ 900万万亿。
4.1长整型直接量需要在数字后面加L 或 l（小写的特别像数字1，所以建议加大写的L）。
4.2运算时会有可能溢出，建议在第1个参与运算的数字后面+L.
//long类型的使用演示
//在使用long类型时，直接量后缀记得加上L 代表是long类型
//long a =100000000000;编译错误，不加L的整数直接量为int类型
// int类型最多存21亿所以报错。
long a1 = 10000000000L; //100亿
//---------------------
//20亿
long a2 = 1000000000210L;//200亿
//30亿
long a3 = 1000000000310L;
System.out.println(a2);//结果是200亿
//System.out.println(a3);//结果不是300亿，而是溢出的结果。
long a4 = 1000000000L3L10L;
System.out.println(a4);

5.float(4个字节)
JAVA提供的浮点型数据类型，其内存占用4个字节，float分为单精度浮点数.采用了科学计数法。
使用科学计数法的方式目前学习中基本不用。
5.1浮点数类型的直接量，默认为double类型，在表示是float类型时，需要加上后缀F /f (建议大写)
5.2浮点数类型在计算时会存在误差。
6.double(8个字节)
JAVA提供的浮点型数据类型，其内存占用8个字节，非常常用。
6.1浮点数类型的直接量，默认为double类型，需要加上后缀D / d(建议大写)
6.2浮点数类型在计算时可能会存在误差。

public class DataTypeDemoFloat {

public static void main(String[] args) {
//float使用演示
//float f = 3.14;//默认double需要加后缀F,才能表示它是float类型
//声明一个float类型的变量
float f = 3.14F;
//重点 double
double d = 3.1415926D;//浮点型直接量默认double 也可加后缀D
double a = 3.0;
double b = 2.9;
System.out.println(a-b);//程序员所要知道的现象不精确
double c =6.0;
double c1 =4.9;
System.out.println(c-c1);//结果无限接近准确数值不精确
double e = 6.0;
double e1 = 1.9;
System.out.println(e-e1);//结果准确

}

}

7.char(占2个字节)
JAVA中字符类型用char来进行存储。内存占用2 个字节。字符的本质：一个字符对应一个码。
码的范围(0-65535),JAVA用的是Unicode编码格式。（www.Unicode.org）
https://www.unicode.org/Public/13.0.0/charts/CodeCharts.pdf

7.1Unicode：统一码，全国码，将多有的国家字符进行收录并划分很多个子集。在JAVA中我们用的是Unicode中最常用的码表(ASCIi)(0-65535)
ASCII中（‘a’ -----97 ‘A’ ------65 ‘0’-------48）
在抗日战争中，发电报或者发摩斯密码。

0001 0002 0003 0004

敌 			军			来			袭

7.2字符使用只能放在单引号中使用，有且只能有一个字符！
7.3特殊符号中如果想打印出来的话，需要在需要转义的字符前加来进行转义(转换原本存在意思)。
//使用演示
char c = ‘@’;
char c1 = ‘#’;
char c2 = ‘女’;
//char c3 = ‘15’;编译错误，char字符中只能存放单个字符！
//一字符对应一个码
//char c4 = 97;
//System.out.println(c4);
//char c5 =64;
//System.out.println(c5);
//‘代表单引号的意思
char c6 =’’’;
System.out.println(c6);
char c7 =‘男’;
System.out.println((int)c7);

8.boolean(占用1个字节)
该类型使用的还是非常多的，所以说非常重要，但是当前章节我们只需要知道如果存储数据就可以了。boolean中只能存一个数据 ,要么是true(成立/真) 要么是false(不成立/假) 。

    //boolean b  = '1';编译错误，boolean只能存true或false
    boolean b = true;
    System.out.println(b);
    boolean b1 = false;
    System.out.println(b1);

类型转换
JAVA中类型转换分为两种：自动类型转换强制类型转换
1.自动类型转换：将一个小的数据类型转到了大的数据类型当中的过程。
//自动类型转换：
int a = 50;
long c = a;//发生了自动转换

double d =c;//发生了自动转换

double d1 =5.0;//没有发生转换！

2.强制类型转换：将一个大的数据类型转到了小的数据类型当中的过程。(会存在数据精度丢失或者溢出的问题)
//强制类型转换
int n = 2147483647;
//现在再用大的类型往小的类型里面装
//存在溢出风险。 byte最大能装 -128~127
//n里面存的是 21亿多
//在需要强制的变量前面加上要转换的类型,用小括号括住。
byte b2 = (byte)n;
System.out.println(b2);//会溢出
double d2 =3.14;
int n2 = (int)d2;
//如果拿小数类型强制为整数类型时，会自动截断小数点后面的所有
//数据（不会进行四舍五入）
System.out.println(n2);

int n3 = 100;
byte b3 = (byte)n3;
//大类型转小类型可能存在溢出情况
System.out.println(b3);//100 没有溢出
规则：byte、short、char类型，在参与数据运算时，会自动转换为int类型。
byte b = 50;
byte b1 = 60;
//两个byte运算会自动转换为int类型
byte b2 = (byte) (b + b1);
int n = b + b1;
short s = 10;
short s1 = 20;
//两个short运算会自动转换为int类型
short s2 = (short) (s + s1);

char c = ‘2’;
char c1 = ‘2’;
//两个字符相加，如果直接输出不用char类型存储的话
//我们输出的就是一个码（数值）
//System.out.println(c+c1);//100
//System.out.println(2+c);//52
//
char c2 = ‘2’+‘2’;
//两个字符相加，如果用char类型存储的话
//我们输出的就是一个计算后码对应那个字符
System.out.println(c2);
//直接输出 '我’的字符码+'你’的字符码相加和
System.out.println(‘我’+‘你’);
Unit04-运算符
一、数学运算符
1.加减乘除（+ 、- 、* 、 / ）取余（%）
取余：也称之为取模，用来求A除B的余数。例如求5除以2的余数：5%2 即可得出余数1。
//5加2
System.out.println(5+2);//7
//5减2
System.out.println(5-2);//3
//52
System.out.println(52);//10
//5除以2
System.out.println(5/2);//2
//-----------------------
//%取余的符号
//5%2意思：得到5除以2的余数
System.out.println(5%2);//1
int number = 8;
int number1 =2;
//result 结果的意思
int result = number / number1;
System.out.println(reslut);//4
//返回余数
System.out.println(number%number1);//商4余数为 0

二、自增自减、关系运算、逻辑运算
1.自增自减，在自身基础上增加1或者减少1。
自增：变量名++， ++变量名
自减：变量名–， --变量名
1.1 单独运算时，加加减减在前在后都一样,都是在自身基础上增一或减一。
1.2参与运算时，加加减减在前在后不一样！！！
加加在前先自增在运算。加加在后，先运算在自增。
减减在前先自减在运算。减减在后，先运算在自减。

//------------自增自减运算----------------

int a = 5;
int b = 5;
a++; //相等于 a = a +1;
b++; //相等于 b = b +1;
++b; //相等于 b = b +1;
b–;
System.out.println(a);
System.out.println(b);

//------参与运算（赋值也算运算！！！！）--------
int a1 = 5;
int a2 = 5;

int result1 = --number2 - number3++;
System.out.println(number2);//4
System.out.println(number3);//6
System.out.println(result1);//-1

2.关系运算符
关系运算符主要是用来比较数值(数据)的大于或小于、等于或不等于的关系。
符号：大于号(>) 大于等于(>=) 小于号(<) 小于等于号(<=)
等于号(==) 不等于(!=)
关系运算符返回的所有结果都为boolean类型
要么是true(成立/真) 要么是false(不成立/假)

A = 19 B = 20 boolean(true/false)
>
问：A的值大于B的值吗？----------- false
A = 60 B = 60
>=
问：A的值大于等于B的值吗？-------- true
A =50 B =49
==
问：A的值等于B的值吗？-------------false

问：A的值不等于B的值？-------------true

问：B的值小于等于A的值？-----------true
//所有参与关系运算符的结果都为boolean
int ageA = 18;
int ageB = 19;
boolean result= ageA >ageB;
System.out.println(result);//false
System.out.println(ageA int ageC = 18;
System.out.println(ageA>=ageC);//true
//双等号是判断两个变量中的值是否相等
System.out.println(ageA ==ageB);//false
//不等号是判断两个变量中的值是否不相等
System.out.println(ageA !=ageB);//true
//--------------强化--------------
//下面的这个式子中优先算四则运算后再去判定关系
System.out.println(ageA+ageC>ageB);//true
//ageA取余2 的结果等不等于0
//ageA的值是18 18除以2 商9 余 0
System.out.println((ageA%2)==0);//true
//ageA18 ageB 19
//加加在后先运算再自增！
System.out.println(ageA++ ==18);//true
//减减在前先自减再运算！！
//上面的代码ageA后自增所以ageA的值为19, --ageB先进行自减由原来的19变为18 //于是 19 == 18 结果为false
System.out.println(ageA == --ageB);//false
// 下面代码–在ageA前，所以先自减由原来的值19变为18
// //于是 18 == 18 结果为true
System.out.println(–ageA == ageB);//true
3.逻辑运算符
JAVA中逻辑运算符分为3种与或非。
3.1 与：就是并且的关系。语法：&&
3.2 或：就是或者的关系。语法：||
3.3 非：就是结果取反的意思。语法：!
逻辑与(并且) ：&& 表示的就是两个或多个条件都成立的情况下结果才为true
问：你能毕业吗？并且的现象：见false即false 一假俱假的关系
条件一：你课程学完了吗？ true false false true
并且
条件二：考试都及格了吗？ false true false true
```
            结果：false      false    false      true  
```

逻辑或(或者)：|| 表示的就是两个或多个条件有一个成立情况下，结果就是true
问：能结账吗？或者的现象：见true 即true 一真俱真的关系
条件一：微信有钱吗？ true false false true
或者
条件二：带现金了吗？ false true false true

            结果： true        true       false     true

逻辑非(取反)： !

true !true 非真即假
结果：false
false !false 非假即真
结果：true
int a = 10;
int b = 5;
int c = 15;
//逻辑运算符返回的类型都为boolean
//计算机处理逻辑运算符是从左至右的顺序！
boolean result = a >= b && a < c;// true && true
// System.out.println(result);//true
// //四则运算先做，再做关系运算
// true && false
// System.out.println(c<=b+a && b>c);//false
// //false || true
// System.out.println(++c<=a+b||c>a); //true
// System.out.println(!true);//false
// System.out.println(!false);//true

//判断一个数是否是偶数
// int number = 4;
// //怎么判断number 是否是偶数
// //判断一个数是否是偶数的标准：能否被2整除。
// System.out.println(number%2 ==0);
//判断年份是否是闰年？
//判断是否是闰年的条件：
//条件一：年份能被4整除并且年份不能被100整除
//或者
//条件二：年份能被400整除。
//扫描器：主要扫描用户输入的控制台数据并可以进行读取。
// Scanner java提供的API
//创建一个扫描器
Scanner s = new Scanner(System.in);
System.out.println(“请输入一个年份，系统会根据年份判定是否是闰年”);
//调用扫描中获取控制台输入的int类型的数据。
int year= s.nextInt();
//条件应该怎么写？
boolean result1=
(year % 4 ==0 && year % 100 !=0) || year % 400 ==0;
System.out.println(result1);
}

三、短路逻辑、赋值运算、复合赋值运算
1.短路逻辑
举例：短路与(并且)
相亲成功的必要三个条件：
1.相对对象是男的 false
&&
2.孝敬父母 true
&&
3.勤俭持家 true
相亲成功！true

举例：短路或(或者)
相亲成功的条件，满足其一即可！
1.漂亮！ true
||
2.勤俭持家。
//短路与的使用演示
int n = 10;
int n1 = 20;
//从左至右来执行
//短路与,因为第一个条件就不成立了，
// 因为是并且的关系，所以后面成不成立结果都是不成立
//然后系统就不在执行后面的条件了，所以++也没有做。
//System.out.println(n > n1 && ++n>0);//false
//System.out.println(n);//10
//短路或！
//因为是或者的关系,所以如果第一个条件成立的话
//后面就直接短路了！因为程序不会在往后运行，结果直接为true。
// System.out.println(++n0);//true
// System.out.println(n);//11
// System.out.println(n1);//20
int number = 10;
int number2 = 20;
//&&是两者都要满足！！
//问：发生短路了吗？
// System.out.println(number // System.out.println(number);//11
//||是或者的关系两者满足其一即可！
//false
System.out.println(number2=10);//true
System.out.println(number);//11

3.赋值运算
赋值号： = 赋值的过程，是从右往左赋值
复合型赋值：+= 、 -= 、=、 /= 、%=
int a = 10;
//在a的自身基础上+10
// a+=10; //等价于 a = a +10;
//System.out.println(a);//20
//在a的自身基础上-10
// a-=10;
//a++;//在自身基础上+1
//在自身基础上+20
//a+=20;
//System.out.println(a);//30
//a=2;
//System.out.println(a);

四、字符串链接、三元运算
1.字符串：一串字符，用双引号来包裹字符串
1.1使用+号时，如果两边都是数值，则进行运算操作！
1.2使用+号时，如果有一方是字符串时，则进行链接操作并都变成一个字符串！！
“hello Java” //所见即所得！
int age = 18;
System.out.println(“我的年龄是” + age + “岁”);//“age18”
System.out.println(10+10+""+30);//2030
System.out.println(""+10+10+30);//101030
System.out.println(10+10+30+"");//50
2.三元运算符
2.1 boolean ? 值1 : 值2；
判断的逻辑？成立返回值1 ：不成立返回值2；
//---------三元运算符的测试----------------
int a =5;
// boolean ? 值1：值2；
//条件成立返回值1 不成立则返回值2
int result = a > 10 ? 1 : 0;
//System.out.println(result);

int number = 10;
int number1 = 20;
//求两个数的最大值
int max= number > number1 ? number : number1;
System.out.println(max);

Unit05-随机控制泡泡和分支流程控制
一、随机数、随机生成泡泡
1.随机数
Java中提供随机数相关的内容，可以将数值随机生成出来。可以根据自己的逻辑让系统
随机一个区间。例如随机（1-10）的浮点数数值。
1.1Math类提供Random方法，返回 0-1 的数值最多到0.9 ，左开右闭的现象。
// 0 - 1 的随机数不到 1
//double r = Math.random();
//System.out.println((int)r);
//如果我想要0-10 应该怎么办？？
//double r = Math.random()*10;
//如果想要0-10 那么就×10 同理想要随机0-100 就×100
//double r = Math.random()*100;
//如果想要拿到 100 到200区间的随机数
// 公示：随机数（最大值-最小值） + 最小值。
int r= (int)(Math.random()(200-100)+100);
System.out.println®;

二、随机控制泡泡大小颜色方向
// 代码块在类中写上一组花括号 { }
//在花括号中再进行调用功能。
//随机大小
int d = (int) (Math.random() * (60 - 10) + 10);
//随机位置
int x = (int) (Math.random() * (800 - d));
int y = (int) (Math.random() * (600 - d));
//随机颜色 R G B
int r = (int) (Math.random() * 256);
int g = (int) (Math.random() * 256);
int b = (int) (Math.random() * 256);
//将随机好的三原色的数值以下面的形式生成一个颜色
Color color = new Color(r, g, b);
//随机横向偏移量
double offsetX = Math.random() * (6 - 1) + 1;
//随机垂直偏移量
double offsetY = Math.random() * (6 - 1) + 1;
{
//随机横向偏移量的正负
offsetX = Math.random() > 0.5 ? -offsetX : offsetX;
//随机垂直偏移量的正负
offsetY = Math.random() > 0.5 ? -offsetY : offsetY;
}
//绘制的功能 g代表画笔
@Override
public void painting(Graphics2D g) {
//移动
x += offsetX;
y += offsetY;
g.setColor(color);
//绘制的位置 x,y 大小宽高 w , h
g.fillOval(x, y, d, d);
}

//程序主入口
public static void main(String[] args) {
RandomBubble b = new RandomBubble();
//开启窗口
b.start();
}

三、流程控制、if单路分支、双路分支
1.流程控制分为三种：1.顺序结构 2.分支结构 3.循环结构(后续讲)
1.1顺序结构: 逐语句一行一行往下执行的顺序。
1.2分支结构：有条件的执行某个语句的结构，并非每句都走。
例如：购物满500打8折 ----------条件是满500 --------满足就打8折单路分支结构 if
购物满500打8折，不满500打9折--------条件是满足500 -----满足打8折 ----不满足打9折 if…else

：分数大于等于60 并且小于80 输出及格
* D：分数小于60 输出不及格
* */
Scanner s = new Scanner(System.in);
System.out.println(“请输入你的成绩”);
double score = s.nextDouble();
//1.判断score中的59大于90吗？不成立则跳到下一个else
if(score >= 90){
System.out.println(“优秀”);
//2.判断score中的59大于等于80吗？不成立则跳到下一个else
}else if(score>=80 ){
System.out.println(“一般”);
//3.判断score中的59大于等于60吗？不成立则跳到下一个else
}else if(score>=60 ){
System.out.println(“及格”);
//4.没有if语句直接执行else的代码块内容。
}else {
System.out.println(“不及格”);
/}
//---------------------------------

FOUNDATION02
Unit06—面向对象编程、对象与类
1.面向对象编程。
OO(Object Oriented) 面向对象
OOA：面向对象的分析
OOD：面向对象的设计
OOP : 面向对象编程 (重点)
高质量代码：复用性好，扩展性好，维护性好，可移植性要好，健壮性 , 效率性和可读性！
面向对象三大特征：封装、继承、多态。
2.对象，类。
类：一类事物的抽象，指的是类别。
对象：真实存在的物体，在软件中指的就是存在的个体。
2.1创建一个Ball类
**

泡泡类：泡泡的模板可以通过这个类创建很多不同的对象(具体的泡泡！)
*/
public class Ball {
//泡泡大小
int d;
//位置x
double x;
//位置y
double y;
//颜色r g b值
int r;
int g;
int b;
//颜色类型
Color color;
//偏移量 X 和 Y
double offsetX;
double offsetY;
}

public class TestDemo {

public static void main(String[] args) {
//在程序中创建对象一定要现有类才有对象！
//创建一个Ball类的具体对象 ,这个对象通过起的名字来使用。
Ball ball1 = new Ball();
ball1.d = 60;
//…
Ball ball2 = new Ball();
ball2.d =100;
System.out.println(ball1.d);
System.out.println(ball2.d);
}
}
3.引用类型
JAVA中除了基本类型外都是引用类型，引用类型存引用，通过引用来访问堆中的具体对象。
image-20211024110407386

4.构造器
4.1使用构造器保证与类名一致。
4.2构造器一般用于初始化类中变量使用，当类被new关键字创建对象时，会自动调用构造器。
什么是构造器：构造器是创建类对象必备的一个语法,通常没有写类中的构造器时，系统会自动送一个无参构造器来支持创建对象的操作也可以称之为默认构造器,还可以进行快速初始化赋值的操作。
为什么要用构造器：因为当一个类中有很多变量需要在创建具体对象时进行赋值数据，如果不用构造器的话，我们就需要按照下面的这种方式来进行赋值，可以看得出代码非常冗余复杂。
ball1 = new Ball();
ball1.d = ?;
ball1.x = ?;
ball1.y = ?; 只是一个球对象就需要调用将近10行赋值！非常繁琐的赋值！！
ball1.color =?;
ball1.r =？
ball1.g =？
ball1.b =?
ball1.offsetX;
ball1.offsetX;
怎么使用构造器：构造器非为两种形式：一种是无参数的构造器一种有参数的构造器。
以Person类为案例
class Person{
//Person的无参数构造器
Person(){

//Person的有参数构造器为什么写有参数，因为我希望在创建对象时，可以通过小括号直接进行数据的赋值
Person(参数1,参数2){

}

class Test {
public static void main(String[] args) {
Person p = new Person(“小黑”,22);
System.out.println(p.name);
System.out.println(p.age);
Person p1 = new Person(“小红”,16);
System.out.println(p1.name);
System.out.println(p1.age);
//编译错误：如果Person类加了有参数构造器不加无参数构造器则报错
//Person p2 = new Person();
//加了则不报错。
Person p3 = new Person();
p3.name =“小王”;
p3.age = 80;
System.out.println(p3.name);
System.out.println(p3.age);
}
}

4.1构造器重载：Peson类中存在无参数的构造器也存在有参数的构造器这个现象就是重载。
好处：在创建对象时，可以使用无参数的构造器创建对象也可以使用有参数的构造器创建。
5.使用构造器优化Ball类初始化的内容。
//无参数的构造器
Ball() {
//随机大小
d = (int) (Math.random() * (60 - 10) + 10);
//随机X和y
x = Math.random() * (800 - d);
y = Math.random() * (600 - d);
//随机颜色的值
r = (int) (Math.random() * 256);
g = (int) (Math.random() * 256);
b = (int) (Math.random() * 256);
color = new Color(r, g, b);
//随机偏移量X 和 Y
offsetX = Math.random() * 6 + 1;
offsetY = Math.random() * 6 + 1;
//随机方向
offsetX = Math.random() > 0.5 ? -offsetX : offsetX;
offsetY = Math.random() > 0.5 ? -offsetY : offsetY;
}
6.方法
方法又称之为函数表示的功能！用来封装一些重复计算重复执行的程序，可以减少代码冗余,可以复用(一次定义多次使用！)。
6.1 语法结构： [访问修饰符] 返回值方法名称 ([参数列表])
访问修饰符：代表控制当前方法功能的可见范围（后续会详细讲）

   返回值 ：没有业务需求用void关键字来修饰，代表是没有返回值的含义。

					如果有的话，返回值的类型 可以是基本数据类型/引用数据类型 /自定义类型。

				   用return关键字来进行返回。//  return  类型;

  方法名称：遵循Java命名规范，要见名知意，小驼峰命名法。

  方法参数：又叫形式参数,主要是根据实际业务需求用来占一个位置，供外部访问时传递！

6.2方法的类型：1.无参数无返回值类型 2.有参数无返回值 3.有参数有返回值 4. 无参有返回值。
6.3方法的调用。
6.4方法的重载条件：方法名一样，参数类型或者参数个数不一样时就可以构成重载。
main(){
取款();-----1行
查询();------1行
转账();-------1行
}
取款(){
500行
}
查询(){
200行
}
转账(){
1000行
}

1.无参数无返回值的方法使用
// [访问修饰符] 返回值方法名称 ([参数列表]){}
//定义一次可以多次使用 ----复用！
static void method(){
System.out.println(“直拳”);
System.out.println(“摆拳”);
System.out.println(“上勾拳”);
System.out.println(“侧踹”);
}
2.有参数无返回值的方法使用
public static void main(String[] args) {
//调用方法
//实际参数：具体实际意义的参数了
hello(“郑皓文”);

//    返回值   方法名  小括号
//就是一个问候的功能方法
//有参数的方法了！String
//方法的小括号中的参数叫
//形式参数(就是占个位置 供调用的地方传入具体的内容)
//有参数的方法具有非常灵活性的！
static void hello(String name)
{
    System.out.println(name+"你好");
}

3.有多个参数的使用
public static void main(String[] args) {
// addMethod(50000,20000);
// addMethod(20,30);
//在调用方法时，一定要根据方法所需要的参数类型和参数个数进行传递
addMethod(10,20);
}
//写一个计算两个数相加的功能（方法）
// 返回值方法名小括号() 花括号{ }
//是否需要两个数据？就需要写上形式参数
static void addMethod(int a, int b) {
//做具体的功能
int result = a + b;
System.out.println(result);
}
}
4.有返回值有参数的方法

public static void main(String[] args) {
//调用
int number = addMethod(11,20);
//接受返回值一定是有后续业务逻辑
//判断结果是偶数吗？
System.out.println(number %2 ==0);
}
//void代表是没有返回值的
// 需要返回什么类型就写什么类型的返回值！
static int addMethod(int a, int b) {
//做具体的功能
int result = a + b;
//用return 关键字来返回结果！
//注意返回的结果必须跟当前方法返回值类型匹配！！！
return result;
}
5.方法的重载
为什么要用重载：当相加的方法想要实现不同数据的相加功能时，可以使用方法的重载来进行定义。

好处：当方法的参数类型或参数个数发生变化时，我们不需要在去定义一个其它名字的方法了，我们可以用一个

	方法名来代表不同的计算的功能。

重载条件：方法名一样，参数类型或者参数个数不一样时就可以构成重载。

public static void main(String[] args) {
addMethod(10, 20);
//-----------
addMethod(90.6, 57.1);
//-----------
addMethod(10,20,30);
}
static int addMethod(int a, int b) {
//做具体的功能
int result = a + b;
//用return 关键字来返回结果！
//注意返回的结果必须跟当前方法返回值类型匹配！！！
return result;
}
//实现方法的重载
static double addMethod(double a, double b) {
//做具体的功能
double result = a + b;
//用return 关键字来返回结果！
//注意返回的结果必须跟当前方法返回值类型匹配！！！
return result;
}
static int addMethod(int a, int b,int c) {
//做具体的功能
int result = a + b +c;
//用return 关键字来返回结果！
//注意返回的结果必须跟当前方法返回值类型匹配！！！
return result;
}

6.泡泡的移动和绘制功能方法重构，封装到泡泡类中
//public 公开的：访问权限最大
//泡泡类的移动代码供具体对象去使用
public void move() {
x += offsetX;
y += offsetY;
if (x > 800 - d) {
offsetX = -offsetX;
x = 800 - d;
}
if (x < 0) {
offsetX = -offsetX;
}
if (y > 600 - d) {
offsetY = -offsetY;
y = 600-d;
}
if (y<0) {
offsetY = -offsetY;
}
}

//绘制泡泡的功能需要画笔
public void paint(Graphics2D g){
g.setColor(color);
g.fillOval((int)x,(int)y,d,d);
}
7.测试代码

public class TestDemo2 extends App {
Ball ball1 = new Ball();
Ball ball2 = new Ball();
public static void main(String[] args) {
TestDemo2 t = new TestDemo2();
//开启窗口
t.start();
}

public void painting(Graphics2D g) {
//球1 绘制
ball1.paint(g);
//球1移动
ball1.move();
//球2 绘制
ball2.paint(g);
//球2移动
ball2.move();
}
}
7.对象内存管理
JAVA程序运行时。变量和对象都分配在内存空间中，并且Java自动管理内存的，一般不自行干预。
内存分为三大区域：方法区、栈区、堆区。
1.方法区：是一个静态区，当编译保存时，会生成一个.class文件，Java会自动将当前的.class文件加载到方法区。
2.栈区：是用来存放局部变量的区域，局部变量指的就是方法中声明的所有变量方法执行完以后立即销毁。
3.堆区：是用来存在全局变量和对象的区域。当new对象时，会将对象分配在堆区。如果堆区中的对象没有被引用，那么则会变成内存垃圾，会有系统进行清理（垃圾回收器）。
局部变量：分配在栈中，用完立即销毁。在方法中声明的所有变量都是局部变量！只能被当前最近的花括号中所使用，别的地方访问不到。
全局变量：分配在堆中，是被当前类成员共享。
Unit07—数组与循环流程控制
int sorce = 80;
int sorce = 70;
int sorce = 50;
int sorce = 10;
//…100遍
数组
定义：代表一组相同的数据类型元素的集合。数组也是一种数据类型（引用类型）
1.1数组的定义和初始化。
1.2访问数组的内容。
数组可以理解为衣柜、橱柜。

int a ; //声明一个int类型的变量名为a
int[] b;//声明一个int类型的数组数组名为b
int 和 int[] 是两个完全不同的数据类型。


 public class ArrayDemo {
 
 public static void main(String[] args) {
 //1.数组的定义
 //在内存中开辟一块空间 里面存了三个元素为int类型的数据
 // int[] arr = new int[3];
 // int a;
 // int b;
 // int c;
 //2.初始化 动态(运行时)初始化、
 //动态(运行时才确定的初始化数据的方法
 int[] arr2 = new int[3];
 //静态、编译期确定的数据的初始化方法
 int[] arr3 = {50, 60, 80};
 //arr3 ={50,60,80};这种初始化方式不能分行写！
 // System.out.println(arr2.length);
 //3.怎么为数组中元素赋值
 int[] arr = new int[3];
 int a;
 int b;
 int c;
 b = 10;
 //要给数组的第二块元素赋值
 arr[1] = 20;
 System.out.println(arr[0]);//代表数组中第 1 个元素
 System.out.println(arr[1]);//代表数组中第 2 个元素
 System.out.println(arr[2]);//代表数组中第 3 个元素
 
 }
 }
 循环
 定义：字面意思代表就是重复执行，反反复复的过程称之为循环。
 Java种的循环结构有三种：1.while 2.do…while 3.for(使用率较高)
 循环的语法三要素：1.循环变量的初始化 2.基于循环变量的一个判断条件 3.循环变量的改变(朝着目标去目标)
 跑三圈
 初始 圈数为0
 够三圈吗? 不够 跑一圈 圈数为1
 够三圈吗? 不够 跑一圈 圈数为2
 够三圈吗? 不够 跑一圈 圈数为3
 够三圈吗? 够了不跑了。
 三要素：
 1. int count = 0;
 2. count < 3 ;
 3. count++; 
 
打印6份简历
 初始 份数0
 够6份吗？ 不够 打印一份 份数1
 够6份吗？ 不够 打印一份 份数2
 够6份吗？ 不够 打印一份 份数3
 够6份吗？ 不够 打印一份 份数4
 够6份吗？ 不够 打印一份 份数5
 够6份吗？ 不够 打印一份 份数6
 够6份吗？ 够了 就不打印了。
 三要素：
 1.int count = 0;
 2.count < 6;
 3.count++; 
while
 
 public class forDemo {
 
 public static void main(String[] args) {
 //在控制台中输入 5 次 “明天白天上课！要记住了！不要迟到！”
 for(int i = 0; i<5 ; i++){
 System.out.println(“明天白天上课！要记住了！不要迟到！”);
 }
 //-------------continue关键字-----------------
 //需求：只在控制台中输出 1 - 10区间的偶数，遇到奇数 则中止循环 执行下次循环
 for (int i =1;i <= 10 ; i++) {
 //如果是奇数的话
 if (i % 2 != 0) {
 System.out.println(“当前i” + i + “为奇数”);
 //中止当前循环 执行下一次循环
 continue;
 }
 System.out.println(“当前 i 为:” + i + “是偶数”);
 }
 //----------------break关键字------------------------------
 for (int i = 0; i < 10; i++) {
 if (i > 6){
 System.out.println(“梁星同学肚子疼…不能继续跑圈了”);
 //break 跳出循环体…不在执行循环了。
 break;
 }
 System.out.println(“梁星跑了一圈”);
 }
 System.out.println(“不跑了！”);
 }
 }
 }
 
 重构跑泡泡 的测试代码 
package cn.tedu.Fun2.day02;
 
 
 import cn.tedu.util.App;
 
 import java.awt.*;
 
 
 public class TestDemo2 extends App {
 //通过数组的方式 去存储多个球对象
 //创建了球数组 开辟3块空间
 Ball[] balls = new Ball[100];
 
 //类构造器 初始化
 TestDemo2() {
 //循环为balls数组中的每个元素 创建一个具体Ball对象
 for (int i = 0; i < balls.length; i++) {
 balls[i] = new Ball();
 }
 }
 public static void main(String[] args) {
 
 TestDemo2 t = new TestDemo2();
 //开启窗口
 t.start();
 }
 public void painting(Graphics2D g) {
 //用for来去实现数组中所有的小球 绘制和移动
 for (int i = 0; i < balls.length; i++) {
 balls[i].paint(g);
 balls[i].move();
 }
 }
 }
 
 判断是否吃到的逻辑 
public boolean eat(Ball ball) {
 //代表当前圈的 x 和 y
 double X = x;
 double Y = y;
 double D = d;
 //外部给的圆 x 和 y
 double ballx = ball.x;
 double bally = ball.y;
 double balld = ball.d;
 if (D < balld) {
 return false;
 }
 double a = (X + D / 2) - (ballx + balld / 2);
 double b = (Y + D / 2) - (bally + balld / 2);
 double c = Math.sqrt(a * a + b * b);
 boolean eaten = c < D / 2 - balld / 2;
 //如果吃到了
 if (eaten) {
 //计算吃掉后的圆面积
 double R = D / 2;
 double r = balld / 2;
 double area =Math.PI * R * R + Math.PI * r * r;
 //新圆的半径
 R = Math.sqrt(area / Math.PI);
 //直径 在赋值给当前圆的 直径
 this.d = (int) R*2;
 }
 return eaten;
 }
 数组复制的两种方法演示 
//1.System.arraycopy() 演示：
 //源数组
 int[] src ={10,20,30,40,50};
 // //目标数组
 int[] dest={0,0,0,0,0};
 System.out.println(“没有复制之前 dest 数组的内容”);
 for(int i =0; i System.out.println(dest[i]);
 }
 //1.src 源数组
 //2.srcPos 从源数组的那个位置（下标）开始复制
 //3.dest 目标数组
 //4.destPos 从目标数组的那个位置开始覆盖
 //5.length 要复制过来数组中的数量
 System.arraycopy(src,0,dest,0,src.length);
 System.out.println(“复制以后 dest 数组的内容”);
 for(int i =0; i System.out.println(dest[i]);
 }
 //2.Arrays.copyOf() 演示：
 //源数组
 //源数组
 int[] src = {10, 20, 30, 40, 50};
 //1.源数组
 //2.新数组长度
 //Arrays.copyOf 该方法会返回一个 数组类型 需要用的话就接收。
 int[] newArr = Arrays.copyOf(src, src.length);
 for (int i =0;i {
 System.out.println(newArr[i]);
 }
 
 怎么吃泡泡的判定逻辑
 package cn.tedu.Fun2.day02;
 
 
 import cn.tedu.util.App;
 
 import java.awt.*;
 import java.util.Arrays;
 
 
 public class TestDemo2 extends App {
 //通过数组的方式 去存储多个球对象
 //创建了球数组 开辟3块空间
 Ball[] balls = new Ball[100];
 
 //类构造器 初始化
 TestDemo2() {
 
 //循环为balls数组中的每个元素 创建一个具体Ball对象
 for (int i = 0; i < balls.length; i++) {
 balls[i] = new Ball();
 }
 }
 
 public static void main(String[] args) {
 
 TestDemo2 t = new TestDemo2();
 //开启窗口
 t.start();
 }
 
 public void painting(Graphics2D g) {
 //用for来去实现数组中所有的小球 绘制和移动
 for (int i = 0; i < balls.length; i++) {
 balls[i].paint(g);
 balls[i].move();
 }
 eating();
 }
 
 //正在吃的方法
 public void eating() {
 //一组大球big的数组 一组小球small的数组
 Ball[] big = balls;
 Ball[] small = balls;
 //标识数组
 boolean[] eaten = new boolean[balls.length];
 int number = 0;//用来记录被吃的次数
 for(int i =0;i < big.length;i++){
 
 for (int j = 0; j 
 if(i == j){ //不能自己吃自己
 continue;//中止当前循环，执行下一次
 }
 if(eaten[i]){//如果当前对应大球的索引元素已经被标记为true
 continue;//中止当前循环，执行下一次
 }
 if(eaten[j]){//如果当前对应小球的索引元素已经被标记为true
 continue;//中止当前循环，执行下一次
 }
 if(big[i].eat(small[j])){ //大球 吃传入的 小球 如果吃到的话
 eaten[j]=true;//标识吃到了状态
 number++; //number 吃到的次数增 1
 }
 }
 }
 if (number == 0){ // 代表一次没吃到
 return; //退出方法
 }
 //如果程序能执行到这里，那就开始缩容的处理
 Ball[] arr = new Ball[small.length];
 int index = 0;//索引
 for (int i =0 ; i < small.length; i++ ){
 //记录没有被标记为吃掉状态的小球
 if(!eaten[i]){
 arr[index++] = small[i];
 }
 }
 //将缩容后的球数组 赋值给balls
 balls = Arrays.copyOf(arr, arr.length-number);
 }
 }
  
Unit08—飞机大战和继承
 一、飞机大战 业务分析 
识别对象： 天空 、 英雄机 、 飞机 、大飞机 、子弹 、…
 创建类模板 ：天空类 sky 、 英雄机类 hero 、飞机 类 Airplane 、大飞机BigAirplane 、 子弹Bullet
 每个类还应该有 数据：X , Y ,Width ，height ，step
 行为：移动()
 问题：每个类 都会有一些共性的数据 ，代码冗余。
 继承
 1.生活中的继承：继承财产 ，钱不用自己挣，继承过来我也能花。
 皇位继承：江山不用自己打，自己也能坐！
 2.软件中的继承：代码不用自己写，继承过来也能用！
 好处：复用代码的一种方式。
 继承的适用性：多个类中存在相同的数据()或者行为时，且多个类能在概念上达到统一，is a（是一种的关系！）
 继承的语法： extends 关键字 来实现继承。
 泛化： 从子类提取冗余代码到父类的这个过程称之为泛化！
 继承的演示：
 
 public class FlyingObject {
 double x;
 double y;
 double width;
 double height;
 double step;
 //有参数的构造器 供子类初始化数据
 FlyingObject(double x ,double y ,double width , double height){
 this.x = x;
 this.y = y;
 this.width = width;
 this.height = height;
 }
 //父类的移动方法 让子类去复用
 public void move() {
 y += step;
 }
 
 public String toString() {
 
 return getClass().getName() +
 “x=” + x +
 “, y=” + y +
 “, width=” + width +
 “, height=” + height +
 “, step=” + step +
 ‘}’;
 }
 }
  
Unit09—绘制飞机大战
 绘制窗口的测试代码 
package cn.tedu.Fun2.day04;
 
 import javax.swing.;
 import java.awt.;
 
 
 public class TestDemo extends JPanel {
 //小括号中要给一个具体图片的路径！
 ImageIcon icon = new ImageIcon(“images/background.png”);
 ImageIcon icon1 = new ImageIcon(“images/airplane0.png”);
 ImageIcon icon2 = new ImageIcon(“images/bigairplane0.png”);
 ImageIcon icon3 = new ImageIcon(“images/hero0.png”);
 //重写父类的绘制方法 因为我们要绘制我们自己的图片
 public void paint(Graphics g) {
 //第一个参数 null
 //第二个就是 画笔
 //第三和第四参数代表 位置 x y
 //绘制图片的代码
 icon.paintIcon(null,g,0,0);
 icon1.paintIcon(null,g,10,10);
 icon2.paintIcon(null,g,200,30);
 icon3.paintIcon(null,g,200,400);
 }
 
 public static void main(String[] args) {
 //创建一个 具体画框
 Jframe frame = new Jframe();
 //创建一个 具体画板
 TestDemo panel = new TestDemo();
 //给画框 添加画板
 frame.add(panel);
 //设定一个画框的大小
 frame.setSize(400,700);
 //设置居中
 frame.setLocationRelativeTo(null);
 //设置关闭的菜单
 frame.setDefaultCloseOperation(Jframe.EXIT_ON_CLOSE);
 //设置窗口可见！
 frame.setVisible(true);
 }
 }
  
绘制飞机大战的测试代码
 package cn.tedu.Fun2.day03;
 
 
 import javax.swing.;
 import java.awt.;
 
 
 public class TimerDemo {
 public static void main(String[] args) {
 //创建定时器对象
 Timer timer = new Timer();
 //创建具体的任务
 MyTask myTask = new MyTask();
 //为计时器添加 具体任务
 //第1个参数 填入具体任务
 //第2个参数 延时多久开始执行任务 毫秒数
 //第3个参数 开始后每次间隔多久继续执行 毫秒数
 timer.schedule(myTask,1000,1000);
 }
 //MyTask 是TimerDemo 继承了TimerTask 就必须要实现自己的任务计划
 //必须 重写父类的 run方法
 static class MyTask extends TimerTask {
 public void run() {
 System.out.println(“同学们今天非常棒！继续加油！！”);
 }
 }
 }
 
 内部类：在类中又定义的类叫做内部类。
 成员内部类 比较常用！
 内部类的优点：
 1.可以共享外部类的属性和方法。
 2.对外隐藏类的定义。
 适用性：
 1.如果内部类需要共享外部的属性和方法时 可以使用内部类。
 2.当前定义的类 只为了给另一个类去提供一些功能时， 可以定义为内部类 
package cn.tedu.Fun2.day04;
 
 public class Demo1 {
 public int a = 10;//公开的 属性
 private int b = 20; //私有的属性
 int c =50; //不写修饰符 权限就为默认的！
 public void Fun() {
 System.out.println(b);//类内部可以访问私有的属性
 
 }
 private void Fun2(){
 //私有的方法 只能在类内部访问！
 System.out.println©;//在类内部访问默认的修饰符的变量 c
 }
 void Fun3(){
 }
 }
 
 Test1包下的Demo2类：
 package cn.tedu.Fun2.day05.Test1;
 
 public class Coo extends Aoo {
 void Fun3(){
 //a 编译错误 ，不同包类的子类 是无法直接访问父类的默认修饰的属性
 b =20;//不同包的子类 可以直接访问用protected 修饰的属性！
 Fun();//不同包的子类 可以直接访问用protected 修饰的方法！
 }
 }
 3.final 关键字
 final的单词表示：最终的意思。在Java中可以使用final修饰变量、修饰方法、修饰类。
 1.使用final修饰的变量 可以初始化 但是初始化以后就不能在修改里面的值！
 2.使用final修饰的方法 不允许子类进行重写！
 3.使用final修饰的类 不允许在被子类继承！
 Final修饰的局部变量
 public static void main(String[] args) {
 int a = 10;
 a = 20;
 a = 30;
 a = 1;
 System.out.println(a);//1
 final int b = 20;//用final修饰的局部变量
 //b = 30; 编译错误：用final修饰初始化的变量 不能再二次修改！
 final int c;
 c = 10;
 //c = 0;编译错误：用final修饰初始化的变量 不能再二次修改！
 
 final int[] arr = new int[2];//final修饰的数据类型是引用类型时 ,引用不能更改!
 arr[0] =10;
 arr[1] =20;
 arr[0] =30;
 //arr = new int[3]; 编译错误！不能为arr再从新赋值一个新的地址！
 
 }
 Final修饰的成员变量(成员变量是被属于类对象的)
 public class FinalDemo {
 final int number = 10;//用final修饰的成员变量
 //final int sum;编译错误 用final修饰的成员变量 声明时必须初始化！
 final int age;
 //如果希望是通过创建对象时传递一个具体数据给到用final修饰的成员变量
 //可以用构造器来解决。
 FinalDemo(int age) {
 this.age = age;
 }
 public static void main(String[] args) {
 
 FinalDemo f = new FinalDemo(18);
 //f.number =20;只要用final修饰的变量 就不能第二次 修改
 //f.age = 25;只要用final修饰的变量 就不能第二次 修改
 }
 }
 
 Final修饰的方法 不能被子类进行重写  
package cn.tedu.Fun2.day05;
 
 
 public final class SubDemo extends SuperDemo {
 
 // public void test(){ 编译错误：子类不能重写父类用final修饰的方法！
 //
 // }
 }
 
 package cn.tedu.Fun2.day05.Test4;
 
 import cn.tedu.Fun2.day05.SubDemo;
 
 public class Sub2Demo extends SubDemo {// Sub2Demo 无法继承用final修饰的类！
 
 }
 final总结：
 1.final修饰的变量 （成员、局部） 只能初始化一次，一次以后就不能被修改了！
 2.final修饰的方法 不能再被子类重写！
 3.final修饰的类 不能在被继承！ 
static 关键字
 static是静态的意思，在Java中可以用来修饰成员变量 、也可以结合final去一起使用 则为常量。
 在类中和方法外声明的变量是实例变量
 1.实例变量：是属于每个对象的属性，每个对象都有一份。
 2.静态变量：是属于类的，且只有一份！被所有对象共享！
 3.常量： 是不变的常数。
 静态变量的访问，通过类名打点进行调用。
 package cn.tedu.Fun2.day05;
 
 
 public class Person {
 
 int age;//对象的
 
 String name;//对象的
 
 static String conten =“吃饭睡觉”;//属于类的
 }
 
  
 
package cn.tedu.Fun2.day05;
 
 
 public class Operation {
 
 public static void AddMethod(int a, int b) {
 System.out.println(a + b);
 }
 }
 
 静态方法的调用
 public static void main(String[] args) {
 Operation.AddMethod(10,20);
 
 }
 6.代码块
 代码块都会只执行一次。
 代码块分为两种：1. { } 代表代码块，属于对象的，当类被创建对象时 当类被创建对象时 会先自动调用代码 块里面的内容。  
static { } 代表静态代码块，属于类的，当类 静态成员被访问时，会先调用静态代码块的内容。
 package cn.tedu.Fun2.day05;
 
 
 public class Images {
 //声明如果是单张图片 就直接一个类型变量存储
 //如果是多张图片 就用数组来存储。
 public static ImageIcon[] airplanes;
 public static ImageIcon[] bees;
 public static ImageIcon[] bigAirplanes;
 public static ImageIcon[] boms;
 public static ImageIcon[] hero;
 public static ImageIcon sky;
 public static ImageIcon bullet;
 public static ImageIcon gameOver;
 public static ImageIcon pause;
 public static ImageIcon start;
 
 //静态的变量初始化 放到静态代码块中去做
 static {
 airplanes = new ImageIcon[2];
 for (int i = 0; i < airplanes.length; i++) {
 airplanes[i] = new ImageIcon(“images/airplane”+i+".png");
 }
 bees = new ImageIcon[2];
 for (int i = 0; i  bees[i] = new ImageIcon(“images/bee”+i+".png");
 }
 bigAirplanes = new ImageIcon[2];
 for (int i = 0; i  bigAirplanes[i] = new ImageIcon(“images/bigairplane”+i+".png");
 }
 boms = new ImageIcon[4];
 for (int i = 0; i  boms[i] = new ImageIcon(“images/bom”+(i+1)+".png");
 }
 hero = new ImageIcon[2];
 for (int i = 0; i < hero.length; i++) {
 hero[i] = new ImageIcon(“images/hero”+i+".png");
 }
 sky = new ImageIcon(“images/background.png”);
 bullet = new ImageIcon(“images/bullet.png”);
 pause = new ImageIcon(“images/pause.png”);
 start = new ImageIcon(“images/start.png”);
 gameOver = new ImageIcon(“images/gameover.png”);
 }
 
 public static void main(String[] args) {
 for (int i = 0; i < airplanes.length; i++) {
 System.out.println( airplanes[i].getImageLoadStatus());
 }
 for (int i = 0; i  System.out.println( bees[i].getImageLoadStatus());
 }
 for (int i = 0; i  System.out.println( bigAirplanes[i].getImageLoadStatus());
 }
 for (int i = 0; i  System.out.println( boms[i].getImageLoadStatus());
 }
 for (int i = 0; i < hero.length; i++) {
 System.out.println( hero[i].getImageLoadStatus());
 }
 System.out.println( sky.getImageLoadStatus());
 System.out.println( gameOver.getImageLoadStatus());
 System.out.println( bullet.getImageLoadStatus());
 System.out.println( pause.getImageLoadStatus());
 System.out.println( start.getImageLoadStatus());
 }
 }
 
 为Airplane、BigAirplane 、bullet 、 hero 、sky 的构造器中修改并添加一下代码！
 public class Airplane extends FlyingObject {
 
 public Airplane(double x, double y, double width, double height, double step) {
 super(x, y, width, height);
 this.step = step;
 icon = Images.airplanes[0];//表示读取第一个airplanes图片
 this.width = icon.getIconWidth();//获取图片宽 …
 this.height = icon.getIconHeight();//获取图片高 …
 }
 } 
 
public class BigAirplane extends FlyingObject {
 

 public BigAirplane(double x, double y, double width, double height, double step) {
 super(x, y, width, height);
 this.step = step;
 icon = Images.bigAirplanes[0];//取大飞机数组第一个张图片 为默认图片
 this.width = icon.getIconWidth();
 this.height = icon.getIconHeight();
 }
 
 } 
public class Bullet extends FlyingObject {
 

 public Bullet(double x, double y, double width, double height, double step) {
 super(x,y,width,height);
 this.step = step;
 icon = Images.bullet;//获取子弹图片
 this.width = icon.getIconWidth();
 this.height = icon.getIconHeight();
 } 
public class Hero extends FlyingObject {
 

 public Hero(double x, double y, double width, double height) {
 super(x,y,width,height);
 icon = Images.hero[0];//取hero数组第一张图片设为默认图片
 this.width = icon.getIconWidth();
 this.height = icon.getIconHeight();
 } 
public class Sky extends FlyingObject {
//private 表示y0 只能在当前类内中访问。
private double y0;//代表第二个图片的高度
//右键  找到Generate 点击  然后选择弹出框的第一个选项，然后选项内容全选  点击ok即可！
public Sky(double x, double y, double width, double height, double step) {
    super(x, y, width, height);
    this.step = step;
    icon = Images.sky; //获取天空的图片
    this.height = icon.getIconHeight(); //获取当前天空图片的高度
    this.width = icon.getIconWidth(); //获取当前天空图片的高度
    y=0; //第一个天空的高度
    y0 =-height; //第二个天空的高度
 

 } 
FOUNDATION03
 Unit11—抽象和多态
 1.抽象类
 使用abstract来修饰的类 就是 抽象类，抽象类是不能被创建对象的（实例化对象！）
 在面向对象泛化的过程中，是将子类所具备的共性的属性和方法抽取出来设计为父类，这个父类往往都是半成品的，包含了部分的属性和方法。
 1.半成品的父类，如若防止会被创建对象(创建出来效果不理想) 可以标记为abstract 来修饰。
 一旦被标记为abstract的类 不能被创建对象。
 package Fun3;
 
 public class TestDemo {
 
 public static void main(String[] args) {
 // Cat c = new Cat();
 // c.name = “小白”;
 // c.eat();
 // c.sayHi();
 // Dog d = new Dog();
 // d.name = “旺财”;
 // d.eat();
 // d.sayHi();
 // Animal a = new Animal();编译错误 抽象类是不能被创建对象的！
 }
 }
  
2.抽象方法
 使用abstract来修饰的方法 就是抽象方法，抽象方法是不能有方法体的，且子类必须实现！
 一般如果一个类被标记为抽象时，往往该类的部分方法也可能存在无法写方法体的现象，故标记为抽象方法，约束子类继承以后，必须实现自己的具体逻辑！
 package Fun3;
 
 public abstract class Animal {
 
 String name;//名字
 
 public abstract void eat();//abstract修饰的方法不能有方法体
 public abstract void sayHi();//2.约束了子类实现继承后 必须重写 父类抽象方法。 
}
 
 多态：子类的不同实现。
 代码中的多态：
 1.行为多态：有个动物的父类，子类有狗和猫，狗和猫的叫声不同，这个现象称之为行为多态！
 2.个体多态：父类型的变量 指向子类型的引用，这个现象就叫做个体多态。（向上造型）
 好处：可以使用一个父类型变量 来声明不同子类型的对象。 
动画播放 重构父类代码
 public abstract class FlyingObject {
 //将为子类提供的属性通过protected访问修饰符来修饰。
 protected double x;
 protected double y;
 protected double width;
 protected double height;
 protected double step;
 protected ImageIcon icon;
 protected ImageIcon[] images;//代表存储当前动画帧的图片，如果说没有动画帧图片 则赋值为null
 protected ImageIcon[] boms;//代表爆炸动画效果的图片，没有则为null
 protected int index =0;//播放动画计数器
 敌飞机 

 System.out.println(“index的值:”+index+“index对数组长度取余:”+index%images.length);
 image= images[(index++/20)%images.length];
 }
 }
 更改直接继承自FlyingObject类的天空类的构造 
public Sky() {
 //super(x,y,image,images,bom);
 //super(x,y,对象的图片,动画图,爆炸图);
 super(0,0,Images.sky,null,null); //调用FlyingObject的带参构造
 this.step = 0.8;
 y0=-height;
 }
 更改直接继承自FlyingObject类的子弹类的构造
 public Bullet(double x, double y) {
 //super(x,y,image,images,bom);
 //super(x,y,对象的图片,动画图,爆炸图);
 super(x,y,Images.bullet,null,null);
 this.step = 4;
 }
 更改直接继承自FlyingObject类的英雄机类的构造
 public Hero(double x, double y) {
 //super(x,y,image,images,bom);
 //super(x,y,对象的图片,动画图,爆炸图);
 super(x,y,Images.hero[0],Images.hero,Images.bom);
 }
 Plane类的修改。添加三个构造方法。
 1.无参的构造方法，避免子类编译错误。
 2.有参数的构造方法 ，自定出场的功能定义。
 随机出场的功能定义。
 package cn.tedu.Fun2.day03;
 
 import javax.swing.*;
 import java.util.Random;
 
 
 public class Airplane extends Plane {
 
 //随机出场的方式
 public Airplane() {
      //      默认图片             动画数组        爆炸动画数组
 super(Images.airplanes[0], Images.airplanes, Images.boms);
 this.step = Math.random() * (5 - 1) + 1;//随机速度
 }
 //自定义的出场方式
 public Airplane(double x, double y, double step) {
 
 
 //x y 默认图片 动画数组 爆炸动画数组
 super(x,y,Images.airplanes[0],Images.airplanes,Images.boms);
 this.step = step;//速度
 }
 }
 
 BigAirplane类
 package cn.tedu.Fun2.day03;
 
 import javax.swing.*;
 import java.util.Random;
 
 
 public class Bee extends Plane {
 private double offsetX = 1;//飞的方向
 public Bee(){
 //随机出场初始化
 super(Images.bees[0],Images.bees,Images.boms);//初始化
 offsetX = Math.random()>0.5 ? offsetX : -offsetX;//随机方向
 this.step = 1;//设置速度…
 }
 @Override
 public void move() {
 super.move(); //y+=step
 x+=offsetX;
 if(x <= 0){//当到达左边界
 offsetX = 1;
 }
 if (x >= (420 - width)){//当到达右边界
 offsetX = -1;
 }
 }
 }
 
 修改GameWorld类里面的内部任务类以及添加创建飞机的方法
 private int index = 0;//代表创建的速度
 //myTask 是 GameWorld的内部类
 class MyTask extends TimerTask {
 public void run() {
 index++;
 //间隔16帧 执行1次创建
 createPlane();//调用创建飞机的方法
 for (int i = 0; i < planes.length; i++) {
 planes[i].move();
 }
 for (int i = 0; i < bullets.length; i++) {
 bullets[i].move();
 }
 //执行 敌飞机飞行的任务
 sky.move();
 repaint();//每次移动以后要重新绘制一次！
 }
 }
 //创建 蜜蜂。敌飞机、大飞机的方法
 //0~6区间的数字创建敌飞机
 //7~8区间的数组创建大飞机
 //9 则创建蜜蜂
 public void createPlane(){
 if(index%32 == 0){
 int random =(int)(Math.random()*10);
 Plane p;//声明父类型的变量
 if (random<=6){
 p= new Airplane();//敌飞机
 }else if(random<=8){
 p= new BigAirplane();//大飞机
 }
 else {
 p = new Bee();//奖品
 System.out.println(“蜜蜂”);
 }
 planes =Arrays.copyOf(planes,planes.length+1);
 planes[planes.length-1] = p;
 }
 }  
switch…case ：是JAVA中的分支结构（多路分支结构）
 适用性：只能对整数类型进行判断是否相等的分支结构，不能做逻辑或者范围的处理。
 int 来去做判定是否相等。long是不可以的！
 1.7JDK以后 可以对String 类型进行判定是否相等的处理。
 注意：如果只是对整数进行判等的分支逻辑，使用switch 性能则会更优！
 语音客服：
 中文请按1 英文请按2 …
 查询话费查询请按2、话费套餐查询请按3 …人工服务请按0
 
 //通过控制台 提示用户请输入 中奖等级
 //用户输入1 代表 1等奖1000万
 //用户输入2 代表 2等奖500万
 //用户输入3 代表 2等奖300万
 //如果输入其它数值 提示 抱歉没中奖！
 // Scanner s = new Scanner(System.in);
 // System.out.println(“请输入中奖等级”);
 // int user = s.nextInt();
 if(user == 1){
 System.out.println(“1等奖1000万”);
 }else if(user == 2){
 System.out.println(“2等奖500万”);
 }else if(user == 3){
 System.out.println(“3等奖300万”);
 }else {
 System.out.println(“不存在该奖项！”);
 } // //
 // switch (user){
 // case 1:
 // System.out.println(“1等奖1000万”);
 // break;//遇到break 代表结束当前的分支。
 // case 2:
 // System.out.println(“2等奖500万”);
 // break;
 // case 3:
 // System.out.println(“3等奖300万”);
 // break;
 // default:
 // System.out.println(“很抱歉没中奖！”);
 // break;
 // }
 //分数在 90多 优秀
 // 80多 良好、 70多 一般 60多 及格 以下 不及格
 Scanner s = new Scanner(System.in);
 System.out.println(“请输入成绩来判等等级”);
 int score = s.nextInt();
 switch (score/10){
 case 10:
 System.out.println(“满分 非常棒！”);
 break;
 case 9 :
 System.out.println(“优秀”);
 break;
 case 8 :
 System.out.println(“良好”);
 break;
 case 7 :
 System.out.println(“一般”);
 break;
 case 6 :
 System.out.println(“及格”);
 break;
 default:
 System.out.println(“不及格”);
 break;
 } 
Unit12—匿名内部类与碰撞检测
 匿名内部类
 定义：是在一行代码去实现继承和创建子类具体的逻辑的方法。
 需要有一个条件，必须是可以被继承的父类。类，抽象类 都可以，接口也可以。 
Animal bird = new Animal() {
 @Override
 public void eat() {
 System.out.println(“吃鸟粮…”);
 }
 
 @Override
 public void sayHi() {
 System.out.println(“叽叽喳喳…”);
 }
 };
 bird.eat();
 bird.sayHi();
 总结：1.如果说当前子类只是创建一次，只需要简洁的继承父类，就可以使用匿名内部类。
 2.如果说当前子类不光使用一次，其它地方也需要用，此时应该常规创建类然后常规实现继承。
 3.匿名内部类 一定是可以继承的父类型 才可以使用，如果一个类被final修饰 则不能使用匿名内部类来创建子类。
 4.匿名内部类优点：代码简洁，一行代码就可以实现创建子类并实现继承！
 重构GameWorld类中的action方法
 public void action() {
 //1.创建具体定时器
 Timer timer = new Timer();
 //2.创建具体任务
 MyTask task = new MyTask();
 //3.给定时器添加具体任务
 timer.schedule(task, 1000, 1000 / 100);
 MouseAdapter mouse = new MouseAdapter() {//创建子类 并实现了继承！
 @Override
 public void mouseMoved(MouseEvent e) {
 System.out.println(“1!!!谁动了我的鼠标！”);
 }
 };
 addMouseMotionListener(mouse);
 } 
Unit13—对象周期生成与内存管理
 Unit14—接口造型与记分
 Unit15—游戏状态管理

Java基础篇

Java相关栏目本月热门文章