java面向对象

一.数据类型

1.基本数据类型

数值型

        整型：byte,short,int,long.

        浮点型:float,double.

字符型：char

 布尔型：boolean

2.引用数据类型

类，接口，数组.

3.数据类型占用空间

数据类型	占用空间
byte	1B
short	2B
int	4B
long	8B
float	4B
double	8B
boolean	官方没有明确指出
char	2B

二.运算符

1.算数运算符

运算符		描述
二元运算符	+	可以进行加法运算，也可以进行字符串的拼接
	-	减法运算
	*	乘法运算
	/	除法运算，需要注意整数之间除法运算的结果依然是整数
	%	取模运算，即求余数
一元运算符	num++	自增运算符，先返回num的值，再将num加1
	++num	自增运算符，先将num加1，再返回num的值
	num--	自减运算符，先返回num的值，再将num减1
	--num	自减运算符，先将num减3.1，再返回num的值

2.赋值运算符

运算符	描述
=	将右边的值赋值给左边的变量，如num=5
+=	如num+=5,相当于num=num+5
-=	如num-=5,相当于num=num-5
*=	如num*=5,相当于num=num*5
/=	如num/=5,相当于num=num/5
%=	如num%=5,相当于num=num%5

3.关系运算符

运算符	描述
>	大于
<	小于
==	等于，注意，一个“=”是赋值运算符
>=	大于或等于
<=	小于或等于
!=	不等于

4.逻辑运算符

运算符	描述
&	与运算。当两边表达式都为true时，结果为true,否则结果为false
|	或运算。当两边表达式都为false时，结果为false,否则结果为ture
^	异或运算，当两边结果不同时，结果为true,否则结果为false
！	非运算。如果表达式结果为true,那么计算结果为false,反之亦然
&&	短路与运算。计算结果与&运算符一致，但当第一个表达式为false时，第二个表达式就不再运算
||	短路或运算。计算结果与|运算符一致，但当第一个表达式为true时，第二个表达式就不再运算

5.位运算符

运算符	描述
<<	将二进制位左移指定位数，移动n位就相当于* 2^n
>>	将二进制位右移指定位数，移动n位就相当于/2
>>>	无符号右移，结果会连同二进制最高位的符号位也移动
&	与运算，类似于逻辑运算符，参与运算的两个数字位都为1，结果才为1，否则结果为0
|	或运算，类似于逻辑运算符。参与运算的两个数字位都为0，结果才为0，否则结果为1
^	异或运算，类似于逻辑运算符。若参与运算的两个数字位不相同，则结果为1；若参与运算的 两个数字位相同，则结果为0
~	按位取反运算，二进制数中的每一位如果为0就变成1，如果为1就变成0

6.三元运算符

三元运算符又称三目运算符，是连接三个表达式的运算符，语法格式如下。

条件表达式？表达式1：表达式2
当条件表达式为true时，执行表达式1.否则执行表达式2

7.运算符的优先级

在实际开发中，可能同时使用到多种运算符，而运算符之间的优先级是不同的，优先级越低的运算符越先执行。

优先级	描述	运算符	结合性
1	括号	()
2	正负号	+、一	从右到左
3	一元运算符	++、— —，！	从右到左
4	乘除	*、/、%	从左到右
5	加减	十、一	从左到右
6	移位运算	>>、>>>、<<	从左到右
7	比较大小	>、<、>=、<=	从左到右
8	比较是否相等	==、!=	从左到右
9	按位与运算	&	从左到右
10	按位异或运算	^	从左到右
11	按位或运算	|	从左到右
12	逻辑与运算	&.&(简洁逻辑与)、&（非简洁逻辑与）	从左到右
13	逻辑或运算	||(简洁逻辑或)、|（非简洁逻辑或）	从左到右
14	三元运算符	?:	从右到左
15	赋值运算符	=	从右到左

三.程序控制

1.顺序结构

Java的基本结构就是颗序结构，除非特别指明，否则就按照顺序从上往下一句一句执行。序结构是最简单的算法结构，语句与语句之间，框与框之间是按从上到下的顺序进行的。

2选择结构

①if语句

选择结构用于在代码中做一些逻辑判断，当满足某些条件时，执行某段代码。if语句就是选择结构的代表。通过if语句，能够实现各种各样的逻辑判断。if语句的语法格式如下所示。

if(条件表达式){

        //代码块1

}else if(条件表达式2){

        //代码块2
}else if(条件表达式3)[

//代码块3

}else{
        //代码块n

}

if语句在使用过程中还需要注意以下两点。
(1)如果if选择结构只需执行一条语句，那么可以省略(}。为了提高代码的易读性，建议不省略{}。
(2){}中的代码语句也称为代码块，在代码块定义的常量或变量的作用域仅限于代码快中，在代码块之外不能使用。

②switch语句

除了if语句外，switch语句也是选择结构。switch语句一般用于做一些精确值的判，其语法格式如下所示。

 switch(变量)
 case值1:
        代码块1;
         break;
 case值2:
        代码块2；
         break;
 case值3：
        代码块3；
         break;
 default:
        代码块n;
         break:
 switch语句会根据表达式的值从相匹配的case标签处开始执行，一直执行到break语句处或者switch语句的末尾。如果case全都不四配，则进人default语句。

③选择结构的嵌套

选择结构在使用上可以嵌套，if中的代码块也可以是switch语句，switch语句中的代码块也可以是if语句。通过嵌套，可以判断更加复杂的逻辑。

3.循环结构

①for语句

for循环是最常见的循环结构，它的语法格式如下。
 for(循环初始化表达式;循环条件表达式;循环后的操作表达式){

        //循环体

}

首先执行一次循环初始化表达式，接着判断循环条件表达式，如果为false,则结束循环。如果为true,则执行循环体，之后执行循环后的操作表达式，重复以上操作，直到条件表达式的值为false为止。

②while语句

 while语句相较于for循环更加简单，它的语法格式有点类似于if语句，如下所示.

while(条件表达式){

        //循环体

}

while语句的执行规则也很简单，只要条件表达式的值为true,就会执行循环体，直到条件表达式的值为false时才退出循环。while循环一般用于不确定循环次数的场景。

③do....while语句

不管是for环还是while循环，都会在循环之前判断循环条件，如果条件刚开始就为false，那么循环体就不会破执行，实际开发中，可能存在需要循环体至少执行一次的场景，此时就可以使用do…while循环语句，do…while语句的语法格式如下所示。

do{
        //循环体

}while(条件表达式);

④break和continue语句

在任何循环语句的主体部分，均可用break控制活环的流程。break用于强行退出循环，不执行循环中剩余的语句。而continue则只能终止某次循环，继续下一次循环.

四.数组

1.数组的概述

数组就是一种能够存放相同数据类型的有序集合，或者说它是一个存储数据的容器，可以创建出一个指定长度的数组，这样就可以存储对应条数的数据了。
在Java中，数组的创建方式分为3种，语法格式如下所示。

//方式一、创建出指定长度的数组，数组有多长，就能存储多少数据

数据类型[ ] 数组名=new 数据类型[数组长度];

//方式二，创建数组的同时间数组中存储数据，此时不需要指定数组长度，有多少元素则数组就多
数据类型[ ] 数组名=new 数据类型[  ]（元素1，元素2，元素3，…}

//方式三、方式二的简写方式
数据类型[ ] 数组名={元素1，元素2，元素3，…}；

其中，数据类型可以是任意的基本数据类型和引用类型。

2.数组的常见操作

①通过索引操作元素
数组元素的操作都是通过索引（也称作下标）进行的，当创建了一个长度为的数组它的索引范围是[0，一1]。

②数组的遍历
当数组元素很多时，不可能一个一个使用索引获取元素，而是希望能够通过循环的方式取出数组中的每一个元素，这个操作称作遍历，数组的遍历一般使用for循环遍历，从0遍历到数组长度一1即可。

③获取数组的最值
当需要获取数组的最大值或最小值时，通过常规的思路可能不太好处理，此时可以使用“假设法“。首先股设索引0处的元素是最大值，之后遍历整个数组，每次遍历取出当前元素与所假设的最大值进行比较，如果当前元素比假设的最大值还大，就再假设该元素是最大值，直到数组遍历完毕为止，最后所假设的最大值就是真正的最大值，同理，获取数组的最小值也是通过此思路求得，唯一不同的是假设元素为最小值而进行循环比较。

④有时可能需要查询数组中某个值所在的索引位置，这个操作也可以通过遍历实现，但需要注意，待查找的值可能在数组中不存在，因此需要先假设待查找值的索引为一1。因为一1这个值不可能是数组的索引，因此当遍历结束后如果索引还是一1，就说明没有找到该值。

3.数组的排序算法

①冒泡排序

冒泡排序的核心思想是，在要排序的序列中，对当前还未排好序的全部元素，自上而下对相邻的两个数依次进行比较和调整，让较大的数往下沉，较小的数往上冒，就好像水泡上浮一样，如果它们的顺序错误，就把它们交换过来。

②选择排序

选择排序的核心愿想是：在要排序的一组数中选出最小或者最大)的一个数与第1个位置的数空换，然后在剩下的数中再找最小（或者最大）的与第1
个位置的数交换，以此类推，直到第n一1个元素（倒数第2个数）和第n个元素（最后一个数)比较为止，每一轮排序都是找出它的最小值或者最大值的过程。

4.二分查找法

前面通过遍历的方式查找元素所在的索引，这样虽然能够实现目标，但是当数组过大时，性能可能偏低。而二分查找法是性能更高效的查找算法。二分查找法又称折半查找法，其算法思想是每次查找数组最中间的值，通过比较大小关系，决定再从左边还是右边查询，直到查找到为止。二分查找法的优点是比较次数少，查找速度快，平均性能好；其缺点是要待查表为有序表，且插人、删除操作困难。因此，折半查找法适用于不经常变动而查找频繁的有序列表。

5.二维数组

二维数组的每一个元素都是一个数组，简单来说，二维数组就是“数组的数组”创建二维数组的语法格式如下所示。

数据类型[ ] 数组名=new 数据类型[m][n];
其中，m表示这个数组的长度，n表示这个数组中每个元素的长度。可以不指定,后续动态创建。

6.Arrays工具类

Arrays是Java中提供的操作数组的工具类，通过Arrays类可以很方便地操作数组。Arrays中提供了大量的方法。

方法签名	描述
static string toString (Type[ ] arr)	按照特定的格式将数组转换成字符串
static boolean equals(Type[]arrl,Typel[ ] arr2)	比较两个数组中的所有内容是否相同
static void sort(Type[]arr)	对数组元素进行排序
static int binarySearch(Type[]arr,Type value)	二分法查找某个值在数组中的索引位置

五.面向对象程序设计

1.面向对象的概念

①面向对象的特性
        面向对象具有抽象、封装，继承、多态的特性更符合程序设计中“高内聚、低耦合”的主导，其编写的代码的可维护性、可读、复用性、可扩展性远比面向过程思想编写的代码强，但是性能相比面向过程要偏低一些。
        封装、继承、多态是面向对象的三大特性，这是任何一门面向对象编程语言都要具备的。

        封装：指隐藏对象的属性和实现细节，对外提供公共的访问方式。

        继承：继承就是子类继承父类的特征和行为，使得子类对象（实例）具有父类的实例属性和方法，或子类从父类继承方法，使得子类具有父类相同的行为。

        多态：指的是同一个方法调用，由于对象不同可能会有不同的行为，

2.面向对象编程

①类的定义
Java使用class关键字定义一个类。一个Java文件中可以有多个类，但最多只能有一个public修饰的类，且这个类的类名必须与文件名完全一致，此外，类名需要符合标识符规则，并且遵循大写字母开头的驼峰规则。比如下面的代码就是创建类的代码。

package com.yyds.unit3.demo；

public class Demoobject{

}
 class Entity1{

}
 class Entity2 {

}

②对象的创建
创建对象的语法格式如下。

类名称 对象名称=new 类名称（）；

3.构造方法

构造方法也称作构造器(constructor),用于给对象进行初始化操作，即为对象成员变量的值赋初始值。构造方法的名称必须与类型相同，井且不能定义返回值，不能出现return关键字，构造方法的调用必须通过new关键字调用，语法格式如下所示。
修饰符 类名（形参列表）{ }

接下来给Student分别提供无参构造方法和有参构造方法，代码如下所示。

package com.yyds.unit3.demo;

public class Student {

        //变量，此处也称为成员变量
        String name;                                                                                                                                       int age ;                                                                                                                                               //无参构造方法

        publc student(){
        System.out.println("无参构造执行了");}

        //有参造方法
        publc Student (String stuName,int stuAge){

        name =stuName;

        age=stuAge;
        system.out,println("有参构造执行了");}

        //方法，此处也称为成员方法

        void cat(string food){
        System.out.println(name+"吃"+food);}

        void study(){
        System.out.println("name+"年龄”+age+"岁，在学习Java");}

}

package com.yyds.unit3.demo;

pubIic class Demo5Conatructor{
 public static void main(string[] args)；

//无参构造方法创建对象
 Student student1=new Student （）；

//有参构造方法创建对象
 student student2=new Student("张三"，23);

4.this关键字

this关键字可以调用成员变量、成员方法、构造方法。需要注意的是，成员方法中不能使用this关键字调用构造方法，当使用this关键字调用构造方法时，它必须出现在构造方法的第一行。

this关键字在构造方法中的第一行以 this(参数列表) 的形式出现时，就表示当前构造方法调用了该类中其他的构造方法（于参数列表相匹配的构造方法）：

public class Test1 {
    public Test1(){
        this("张三",18);
    }
    public Test1(String name,int age){
        System.out.println("姓名："+name+"，年龄："+age);
    }

    public static void main(String[] args) {
        Test1 test1 = new Test1();
    }
}

5.static关键字

用于修饰成员(成员变量和成员函数)

被修饰后的成员具备一下特点：

    1、随着类的加载而加载。

     2、优先于对象存在。

     3、可以被所有对象共享   ：当多个对象中有一个属性都相同时，把这个属性定位static，通过对象调用属性就可共享此属性。

     4、可以直接被类名调用，不必创建对象。

6.三大特征

7.super关键字

super可以理解为直接父类对象的引用，或者说super指向子类对象的父类对象在储空间。可以通过super访问父类中被子类覆盖的方法或属性。

1. super调用父类的构造方法，必须在构造方法的第一个
2. super只能出现在子类的方法或构造方法中！
3. super和this不能同时调用构造方法
      

区别点	this	super
引用	this代表本类对象的引用	super代表父类存储空间
使用方式	this属性，this.方法，this()	super.属性，super.方法super()
调用构造方法	调用本类构造方法，放在第一条语句	调用父类构造方法，放在第一条语句
查找范围	先从本类找，若找不到，则查找父类	直接查找父类。

8.final关键字

final关键字，它可用来将一个变量声明成常量，事实上，final关键字还有其他场景的用法。final的意思为最终，不可变。final是一个修饰符，它可用来修饰类、类中的属性和方法以及局部变量，但是不能修饰构造方法，final的用法主要有下面在主类的4种。

·final修饰的类不可以被继承，但是可以继承其他类。
·final修饰的方法不可以被重写。
·fnal修饰的变量是常量，只能被赋值一次。
·final修饰的引用类型变量不能改变它的引用地址，但是可以改变对象内部属性的值。

9.Object类

如果一个类没有用extends关键字继承其他类，那么它默认就继承Object类。java中这么设计的日的是让所有类都拥有一些基本的方法，这些方法都定义在Object类中，并且它们中的一部分可以被重写。

Object类的常用方法

方法签名	方法描述
String toString()	返回该对象的字符串表示形式
boolean equals(Object obj)	判断两个对象的地址是否相同
native int hashCode()	返回该对象的哈希码值
final native Class<?>getClass()	得到一个对象或者类的结构信息
final void wait()	使当前线程进人等待
final native void notify()	唤醒一个等待的线程

    
10.抽象类

在Java中，抽象的关键字是abstract,不管是抽象类还是抽象方法，都用abstract关键字修饰，语法格式如下所示。

权限修饰符 abstract class 类名{ }
权限修饰符 abstract 返回值类型 方法名（参数列表）；

这里需要注意以下4点
(1)抽象方法只有方法声明，没有方法体，它必须交给子类重写。子类重写抽象方法，也称作“实现”抽象方法。
(2)子类如果也是抽象类，则不一定需要实现父类的抽象方法，而如果不是抽象类，则必须实现父类中所有的抽象方法。
(3)抽象方法必须被子类重写，因此抽象方法的访问修饰符不能是private.
(4)由于抽象方法没有具体的方法体，无法用一个抽象的对象调用它，因此抽象类不能被实例化。
(5)抽象类可以有构造方法，它的构造方法的作用是便于子类创建对象时给抽象类的属性赋值。

11.接口

当抽象类中的方法都是抽象方法的时候，该抽象类可以用另外一种形式定义和表示，那就是接口interface。接口就是比“抽象类”还“抽象”的“抽象类”，可以更加规范地对子类进行约束。

接口的定义和使用
定义接口不是使用关键字class,而是用interface修饰，语法格式如下所示。

interface 接口名 [ extends 父接口I,父接口2，…]{

//常量定义

//方法定义

}

对于接口，可以通过子类实现，实现接口的“子类“往往称为实现类。接口中的抽象方法，必须要“子类”去“继承“接口并“重写”这些方法，其语法格式如下所示。

修饰符 class 类名 implements 接口1，接口2，····{

@Override
修饰符 返回值 抽象方法1(）{

}
 @Override
修饰符 返回值 抽象方法2{

}