Day12-面向对象07- 导包，权限修饰词 ，final ，抽象类 ，接口
y01-JAVA语法基础-01
- jdk:java开发工具包，需要将java源文件编译为class字节码文件，jdk包含jre
- jre:java运行所需环境，需要用javac来运行编译好的字节码文件，jre包含jvm
- jvm:java，虚拟机，java可以跨平台运行的关键,javac将.java文件编译成.class文件然后jvm虚拟机会在不同的平台将字节码翻译成平台可运行的机器码。
- 常用的dos命令：cd 切换目录 cd..返回上一级 dir查看当前目录 cls清屏
Day02-JAVA语法基础02-数据类型
- 八种基本数据类型：byte（1字节），short（2字节），int（4字节），long（8字节），boolean（1字节），char（2字节），float（4字节），double（8字节）
- 一种引用数据类型：String字符串类型
- 进制和E：二进制以0b开头，八进制以0开头，十进制正常显示，十六进制以0x开头。E后加正数几浮点数的小数点就往右移几位，E后加负数，浮点数的小数点就往左移几位。
Day03-JAVA语法基础-03运算符
一，
Java中基本数据类型转换
- 自动数据类型转换：小的数据类型向大的数据类型转换时，会自动转为大的数据类型
- 强制数据类型转换：大的数据类型向小的数据类型转换时必须要加上强制类型转换符，而且可能会有数据损失，所以要合理运用，并且要避免数据溢出的错误。
- char和short转换：只能在数值在0到正的三万之间可以互相转换，并且一定要加强制类型转换符。否则就会发生溢出错误
- 常量转换：常量强制类型转换在小的数据类型取值范围内不需要加强类型转换符，如果超出小的类型取值范围则需要加强制类型转换符
二，
java中的运算符
算术运算符
- + ：1.表示正负，2.表示数学中的加号，3.可以拼接内容
- - ：表示数学运算中的减法运算
- * ：表示数学运算中的乘法运算
- / ：表示数学运算中的除法运算
- %：取两个数相除之后的余数
- ++ :两个加号在数值前，数值要先自增一再参与其他操作。两个加号再数值后，数值先参与其他操作再自增一。
- - -：两个减号号在数值前，数值要先自减一再参与其他操作。两个加号再数值后，数值先参与其他操作再自减一
赋值运算符
= ：看见一个等号代码从右往左读，表示将等号右边的值赋值给等号右边的值。
+= ：加等号是将右边的值和左边的值相加，然后赋值给右边的值。
-= ：减等号是将右边的值和左边的值相减，然后赋值给右边的值。
*= ：乘等号是将右边的值和左边的值相乘，然后赋值给右边的值。
/=：除等号是将右边的值和左边的值相除，然后赋值给右边的值。
%=：余等号是将右边的值和左边的值取余，然后赋值给右边的值。
逻辑运算符
| ：逻辑与运算符，只要逻辑与运算符左边和右边有一个条件为true，返回就为true。
& ：逻辑或运算符，只要逻辑或运算符左边和右边有一个条件为false，返回就为false。
! ：非运算符，对使用的值进行取反，true取反为false，false取反为true。
^ ：异或运算符，两边结果相同就为true，两边结果不同为false
|| ：短路与，只要条件左边为true，就不执行右边。
&& ：短路或，只要条件左边为false，就不执行右边。
比较运算符
< ：数学中的小于符号
<= ：数学中的小于等于符号
> ：数学中的大于符号
>= ：数学中的大于等于符号
== ：比较左右两边的值是否相等，相等为true，不相等则为false
!= ：比较左右两边的值是不是不相等，如果不相等则为true，相等则为false
三目运算符：
语法：条件表达式 ？字面值1：字面值2。
条件表达式的判断为true则返回字面值1，条件表达式为false就返回字面值2。
Day04-JAVA语法基础04-流程控制语句
一、选择语句
println输出语句能输出什么？
输出的一定是数据类型中某一种数据类型的字面值
if语句
if(表达式){
//执行体
}if语句是一种判断语句，当括号中的表达式为true的时候，就会执行执行体中的内容，如果括号中的表达式为false的时候，则不会执行执行体中的内容。
if-else语句
if(表达式){
//if执行体
}else{
//else执行体
}if-else语句如果括号中的表达式为true，就会执行if执行体，如果为false，就会执行else执行体。
if-else-if-else
if(表达式1){
//表达式1 if执行体
}else if(表达式2){
//表达式2 if执行体
}else{
//else执行体
}if-else-if-else语句会判断表达式1的值是否为true，如果为true，就执行表达式1的if执行体，不往下执行结束判断。如果表达式1的值为flase就跳过表达式1的if执行体，去判断表达式2是否为true，如果为true，就执行表达式2的if执行体，如果为flase，就会执行else执行体。
switch语句
swtich(字面值){
case 字面值1：
语句1
break;
case 字面值2：
语句2
break;
...
default:
语句
}switch括号中的字面值与case字面值相匹配时，就会执行哪一个case中的case语句，都不匹配，则会执行defaullt中的语句
二，循环语句
for循环
for(初始表达式;条件表达式;迭代语句){
循环体;
}判断条件表达式是否成立，成立就走循环体，循环完之后就会执行迭代语句，然后再判断条件表达式是否成立......。一直到条件表达式不成立，程序就会停止执行。
while循环
while(条件表达式){
循环体
}
当条件表达式为true就执行循环体，一直当条件表达式为false，程序结束。
do-while循环
do{
循环体
}while(条件表达式);程序先执行一次循环体，再做while判断，为true就继续执行循环体再判断，为false就结束。
continue、break、return关键字
continue：跳出本次循环
break：跳出当前整个循环
return：跳出当前的方法
Day05-综合练习
做练习题
Day06-面向对象01-成员变量和成员方法
成员变量和成员方法
成员变量和局部变量的区别
1.定义的位置不同，成员变量定义在类中，而局部变量定义在方法中；
2.作用域不同，成员变量的作用域为当前的整个类，而局部变量的作用域为局部变量定义的地方开始，到下一个大括号；
3.初始值不同，系统会给成员变量赋初始值，要么为null，要么为0，而局部变量不赋初始值系统不会默认赋值，无法使用。
成员方法：自定义的普通方法
main方法 和 自定义的普通方法 都属于成员方法,方法之间不能嵌套！
作用：提高代码的复用性，减少代码量。
自定义方法的分类
1.无返回值无参数
2.无返回值有参数
3.有返回值无参数
4.有返回值有参数
方法的重载
方法重载的构成特点：
两个或两个以上的方法，必须在同一个类中！方法的名字完全一致，但是参数列表不一样，可以是参数的类型不同，可以是参数的个数不同，可以是参数类型的顺序不同。
方法重载的作用：
1.对于调用者来说，只要一个方法名，传不同的参数就可以实现不同功能。
2.提高代码的阅读性
3.节省了命名空间，一个名字可以命名很多方法
Day07-面向对象02-类和对象
类和对象
类是构建对象的模板，是先有得类才有的对象
类是具有相同属性对象的抽象，是抽象的。
对象是抽象类的实例，有状态（属性），有行为（方法），是具体的，而且具有唯一性。
类的分类：
1.含有main方法的类是测试类，目的是为了测试。
2.不含有main方法的类的是模板类，目的是为了创建对象。
创建对象的语法：类名 自定义对象名 = new 类名()；
当main方法入栈，每new一个对象的时候，就会在堆空间开辟一个专属于这个对象的内存。自定义的对象名其实就是指向这个内存空间的地址
创建对象五种方式：1.创建完对象后直接赋值。类名 对象名 = new 类名();
2.先创建对象然后赋值。类名 对象名；对象名 = new 类名()；
3.创建多个对象，然后直接赋值。类名 对象名1 = new 类名(),对象名2 = new 类名();
4.先创建多个，然后再一起赋值。类名 对象名1，对象名2；对象名1 = new 类名(),对象名2 = new 类名();
5.混合模式。 类名 对象名1 = new 类名，对象名2，对象名3 = new 类名();
创建玩对象赋值为null，如 类名 对象名 = null; 对对象名进行操作会报空指针异常，因为赋值为null是没有在堆空间中开辟空间的。
this关键字
this就是指向当前对象的意思，引用当前对象的内存地址。
this再非静态方法体使用，非静态方法只能被对象调用，哪一个对象调用this所在的方法，this就指向这个对象的内存地址。
this的作用:1.区分成员变量和局部变量。当局部变量和成员变量名字一致的时候，带this关键字的就指的是成员变量
2.this搭配方法提高代码复用性。
构造方法
在我们创建对象的时候，系统就已经在调用无参构造方法了。
特点：构造方法不能有返回值和返回值类型，方法名必须要和类名一致，大小写也要一致。可以有创建多个构造方法使参数不一样构成方法重载，来达到不同的功能。
调用构造方法只需创建对象，通过对象来调用构造方法。
作用：构造方法的作用，对属性进行初始化赋值，创建完属性，系统默认给的值，要么是null，要么是0。就可以使用构造函数对属性进行初始化赋值。
我们不创建构造方法的时候，系统会自动创建一个隐式的无参构造方法。如果我们创建了有参的构造方法，系统就不会自动创建无参的构造方法，我们在调用的时候就必须给参数了，不方便我们的使用，有时候我们还没有想好要写什么参数，不传参数就会报错，所以建议最好什么时候都创建一个无参构造方法。
一般都会使用有参构造方法对属性进行初始化赋值，这样可以在创建对象的时候传参对属性进行赋值。
Day08-面向对象03-static和属性封装
构造函数调用其他构造函数
构造函数之间不能够互相调用，但是可以使用this关键字，在一个构造方法中调用另一个构造函数，而且调用的时候必须要写在方法体的第一行
语法：this(括号中有几个参数写几个参数，没有参数不写) 作用：提高代码的复用性
static关键字
是什么：被static关键字修饰的内容都为静态的内容，如静态属性，静态方法，静态内部类，静态代码块。不被static修饰的则称为非静态的，如非静态属性。。。。。
作用：被static关键字修饰的内容，都可以直接用类名来调用，不需要再创建对象去调用。静态的方法只能调用静态的方法，非静态的的方法可以调用静态的方法和非静态的方法，只不过调用的时候本质上还是省略了当前类的类名。static一般用在工具类中，方便通过类名直接去调用方法。
总结来说，static的作用是创建与类相关而不是实例相关的成员，可以通过类名直接访问，无需创建对象。它可以用于定义静态字段、静态方法、静态代码块和静态内部类
封装
封装就是把复杂的东西封装起来，使得操作的时候更加方便。
属性封装就是把属性私有化，可以把内部细节隐藏起来，使得数据更加安全，不会被外部改变。
可以使用private关键字声明属性，这样就变成私有化的属性了，只能在该类中访问。想要在别的类中使用，可以调用封装好的set方法进行设置值，get方法获取值。
封装有以下几个优点：
-
- 数据隐藏：通过将数据私有化（private），可以防止外部直接访问和修改数据，只能通过类提供的公共方法来访问和修改数据。这样可以保护数据的安全性和完整性。
- 代码复用：通过封装，可以将相关的数据和方法组织在一个类中，方便复用。其他类可以通过实例化该类来使用其中的功能，而不需要了解具体的实现细节。
- 简化调用：封装可以隐藏实现细节，使得类的使用者只需要关注如何调用类的公共方法，而不需要了解内部的具体实现。这样可以降低使用者的学习成本和使用难度。
Day09-综合考试
练习考试
Day10-面向对象04-继承
什么是继承？
继承就是一个类通过extends关键字继承另一个类，被继承的类叫做父类，继承的类叫做子类。
继承的作用？
子类如果继承了父类，那么子类就可以共享父类中的属性和方法，通过super关键字去使用，而不用再创建。减少代码量，提高了代码的复用性。
super关键字？
在子类中被super关键字所修饰的指向的就是父类中的特征。super.属性就是指的父类中的属性，super.方法()就是指得父类中的方法。它和this的区别就是this指的是本类中的特征，super指的是父类中的特征。子类中任何构造函数都默认隐式调用父类中无参构造方法，在子类中第一行都隐式的使用super()调用了父类中无参的构造函数，如果父类中没有无参构造，那么子类构造函数就必须去调用父类中的有参构造函数。
super关键字作用？
super一般用在子类有参构造种调用父类有参构造，因为父类中的属性子类中也有，所以就可以直接调用父类中的有参构造，提高了代码的复用性。
方法的重写？
方法的重写就是将父类中的方法在子类中在重新写一遍，但是只是方法体重新写一遍，方法的结构不可以改变，重写方法的权限修饰符必须大于或等于父类中的方法的权限修饰符，返回值，方法名，参数列表都必须不一样。
方法重写的作用？
方法重写的作用就是，父类中的方法不适用于子类中要实现的功能，所以要将方法实现的功能进行重新编写，达到需求。
子类方法体可以完全覆盖父类方法体，但是用的结构也是父类中方法的结构，如果父类中方法的功能正好子类也需要，也可以不完全覆盖，使用super调用后继续添加即可。
静态继承问题
静态的属性和方法也是可以被继承的，可以直接通过过子类类名调用
静态的方法不能被重写，因为静态的方法是与类关联的，子类的对象不能重写类中的方法
属性的初始化，是对象的属性进行的初始化，静态的属性不存储到对象，不能进行初始化！
静态属性是完全可以封装的，只不过get和set要写成静态的方法，然后在set和get中用 类名.属性名。
Day11-面向对象06-多态
多态就是同一个对象，在不同状态下做出的不同行为。用抽象代替具体，使耦合更低，适配性更强，维护性更好。多态只能调用重写的方法，执行的是子类的方法！
多态不能调用子类独有的方法！
形成多态有三个条件 1.有继承关系 2.有方法的重写 3.有向上转型发生。
多态的类型转换
向上转型：将子类实例化对象，用父类类型引用，这样就可以用父类去调用子类中重写过的方法。但是不能调用子类中其他的方法。编译看左边，运行看右边。调用属性看左边，调用方法看右边。
向下转型：必须建立在向上转型的基础上，将已经向上转型的引用类型，通过强制类型转换符，向下转为子类的引用类型，就可以去调用子类中的独有方法。
ClassCastException 类型转换异常？
如果引用类型为空或者转换的类型不匹配就会出现，ClassCastException异常。可以使用运算符 instanceof 判断某个变量引用的对象，是否属于某种类型
多态应用：父类引用类型作为参数
父类作为参数传递可以在方法中直接调用父类中的方法，通过多态的机制接收不同的对象，来调用不同子类中的方法。
父类也可也作为返回值类型，通过返回不同的对象，用父类返回值类型来接收，也可以实现调用子类中不同的方法。
1、Java 中实现多态的机制是什么？
靠的是父类或接口定义的引用变量可以指向子类或具体实现类的实例对象，而程序调用的方法在运行期才动态绑定，就是引用变量所指向的具体实例对象的方法，也就是内存里正在运行的那个对象的方法，而不是引用变量的类型中定义的方法。
2、Java多态有什么优势？
(1)可替换性(substitutability)。多态对已存在代码具有可替换性。例如，多态对圆Circle类工作，对其他任何圆形几何体，如圆环，也同样工作。
(2)可扩充性(extensibility)。多态对代码具有可扩充性。增加新的子类不影响已存在类的多态性、继承性，以及其他特性的运行和操作。实际上新加子类更容易获得多态功能。例如，在实现了圆锥、半圆锥以及半球体的多态基础上，很容易增添球体类的多态性。
(3)接口性(interface-ability)。多态是超类通过方法签名，向子类提供了一个共同接口，由子类来完善或者覆盖它而实现的。
(4)灵活性(flexibility)。它在应用中体现了灵活多样的操作，提高了使用效率。
(5)简化性(simplicity)。多态简化对应用软件的代码编写和修改过程，尤其在处理大量对象的运算和操作时，这个特点尤为突出和重要。
Day12-面向对象07- 导包，权限修饰词 ，final ，抽象类 ，接口
导包：
导包就是把不同包中的类导入到该类中，就可以使用该类中的方法。*星号指的就是所有的意思。import java.util.*就是把该包中所有的类都导入。
权限修饰符：
权限从小到大为 private < 默认的 < protected < public。
1.private 是权限最小的修饰符，用private修饰类就表示内部类，只能在当前内部类的外部类中创建对象。用private修饰的方法就是私有方法，只能在当前类中调用。被private修饰的成员变量只能作用域也在当前类中，其它的类无法操作。
2.默认的，什么修饰符都不写就是为默认的，默认的权限在一个包中，只要在同一个package中，就可以调用方法，操作属性，创建对象。
3.protected 是受保护的意思，被protected修饰的方法可以在不同的包，两个类有继承的关系下，通过方法名直接调用。
4.public修饰符是公开的意思，被public修饰的方法任何地方都可以调用，被publi修饰得类任何类中的可以创建对象。
final关键字：
final可以修饰类，可以修饰方法，可以修饰变量。
1.被final修饰的变量会变成常量，初始化之后无法再次修改值，final修饰成员变量可以先不赋值，然后通过构造函数赋值。
2.被final修饰的方法，将不可以被子类重写。
抽象类：
抽象类就是在calss前面被abstract关键字修饰的类。
抽象类可以解决继承中子类重写父类的时候完全覆盖父类方法体的内容。在抽象类中将方法定义为抽象方法，就可以不用写方法体，有不同不子类重写后再去写方法体，只需要用到结构即可。
抽象类语法特性：
1.抽象类不能被实例化，也就是不可以创建对象。
2.抽象方法一定在抽象类中，但是抽象类中不一定全是抽象方法。
3.抽象类中可以定义普通类中所有可以定义的，还可以写抽象方法
4.抽象类的子类必须重写所继承的抽象类的方法，除非这个子类也是抽象类。
5.抽象类不能用final修饰，抽象方法也不能用final修饰，因为被final修饰的方法都无法被重写，抽象方法也不可以用static修饰，因为抽象类不可以实例化，无法通过对象名直接去调用静态方法，抽象方法的权限修饰符也不可以是private，因为抽象方法要被它的子类重写，如果被private修饰将无法重写。
接口：
接口 就是将表示类的calss改为interface。
1.接口不能被实例化
2.要想调用接口中的方法，就必须用实现类去实现接口。在类名后加implements 接口名，就可以实现该接口，通过实现类的实例化对象去调用接口中的方法
3.接口的抽象方法必须被实现类重写，除非这个实现类是抽象类。
4.一个类可以实现多个接口
5.接口也可以继承多个接口完善了java不能多继承缺点
6.一个类可以继承一个类并且同时实现多个接口
7.接口定义的变量 前面都隐式的写有public static final。
8.接口的方法 前面都隐式的写有 public abstract。
9.接口不可以定义 代码块 静态代码块 构造函数
在jdk1.8跟新之后：1.接口中可以用default修饰方法，方法中可以有方法体。需要实现类创建对象来调用
2.接口中可以用static修饰定义方法，方法中可以有方法体，直接用 接口名.方法名 去调用。
接口的应用场景：
1.接口可以作为参数类型，把接口作为方法的参数，调用方法的时候传递一个实现类对象，使用接口引用类型接收，通过传递不同的对象，调用的方法也不一样。
2.接口可以作为返回值类型，接口作为返回值，可以通过返回不同的实现类对象，达到调用不同对象中的方法的目的。
接口和抽象类的区别：
相同点：1.都不能被实例化，需要子类或实现类创建对象。
2.接口和抽象类的抽象方法都必须被他们的子类或实现类重写，除非它们的子类和实现类都是抽象类
不同点：1.抽象类可以定义非抽象方法，还可以定义构造函数，代码块，静态代码块。而接口只能定义抽象方法。
2.子类只能继承一个抽象类，但是实现类可以同时实现多个接口。
抽象类强调的是从属关系。
接口则强调的是功能。
如下图所示，智能手机类继承手机类，继承它本来的功能。而智能手机只是实现数码相机中拍照的一个功能，实现MP3中播放音乐的一个功能。
Day13-数组-基础
数组：数组就是可以存储大量数据的一个容器。
静态初始化就是声明好之后直接对数组进行赋值，根据赋值元素的个数，数组会在堆空间中开辟相应的长度。
1.数据类型[] 数组名字 = new 数据类型[]{1，2，3，4，5};
2.数据类型[] 数组名字 = {1，2，3，4，5};动态初始化就是先给数组的长度规定好，具体元素是什么，可以动态赋值，如循环赋值，键盘录入赋值......
数据类型[] 数组名字 = new 数据类型[数组长度];数组一旦创建，其长度是不可以改变的。数组中每一个下标都对应着一个一个元素，数组的下标是从零开始的，如果数组的长度是n，那么要访问该数组的最后一个元素就是n-1。
数组的优点：1.可以存储大量的数据
2.对元素的查询速度使得非常快的，因为每一个元素否对应着一个下标，知道下标后可以直接找到该下标对应的元素。
数组的缺点：数组进行元素插入和删除的操作的时候，效率非常低，需要移动大量的元素。
Day14-数组-进阶
一维数组可以存储批量的数据，那么批量的一维数组就可以使用二维数组来存储，批量的二维数组就可以用三维数组来存储，以此类推，可以有多维数组。
动态初始化:数据类型[][] 数组名字 = new 数据类型[二维数组长度][一维数组长度];如下示例:
1. int[][] arr = new int[2][3];
2. String[][] str = new int[3][4];
静态初始化:数据类型[][] 数组名字 = new int[][]{{元素一，元素二，元素三},{元素一，元素二，元素三},{元素一，元素二，元素三},{元素一，元素二，元素三}};
简写:数据类型[][] 数组名字 = {{元素一，元素二，元素三},{元素一，元素二，元素三},{元素一，元素二，元素三},{元素一，元素二，元素三}};
如下示例:
1. int[][] arr = {{1,2,3},{2,3,4},{3,4,5},{4,5,6}};
2. String[][] str = {{"A","B","C"},{"A","B","C"},{"A","B","C"},{"A","B","C"}};java.util.Arrays工具类：
toString():返回指定数组的字符串形式
deepToString():返回多维数组的字符串形式
eqauls():比较两个字符串的内容是否一样
sort():对指定数组进行升序排序
binarySearch():在一个数组中查找指定值的索引 使用此方法前，数组必须进行排序！！！
fill():对数组填充指定内容
copyOf():从数组的第一个元素进行拷贝，然后返回一个新数组
13万+
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
