java基础与面向对象

                 java基础

基本数据类型; `

  整形:Java中用来表示 整形的数据类型
         byte   1   2^7-1    
         short  2   2^16
         int    4   2^31
         long   8   2^51     后面加L
 字符型:Java中用来表示符号文字或者符号的数据类型
         char    2     65535
  浮点型;Java中用来表示小数 的数据类型
          float(单精度小数)不常用     加f
         double(双精度小数)常用
   布尔类型:表示  真,假  对,错  是,否数据类型
    boolean:只有两个值  true  表示真,对,是
                        false 表示假,错,对

引用数据类型:
JDK中封装的类,以及自定义的Java类都属于引用数据 类型
基本数据类型对应引用数据类型除了
char Character
int Integer
剩余的都是首字母大写
Java的类型转换,

      隐式类型转换:

当小范围数据转换成大范围数据会自动转换成int
强制类型转换:
Only you in my life:
.当int类型转换为byte类型时，转换后结果为int类型变量的值与byte类型值的变化范围取模（即相除得到的余数）。byte类型的取值范围为256。300除以256的余数为44

Only you in my life:
当浮点型转换为int型时，会舍去小数部分。当浮点型太大以超出int型的范围时，结果也是对int型的变化范围取模

Only you in my life:
当浮点型转换为byte型时，结果时舍掉小数部分后与byte类型变化范围取模

当大范围的数据类型转换为小范围的时候就需要强制转换
示范float a = (float)5.21;
注意:大转小可能会发生溢出,数据溢出会导致结果不可控一定要注意,有小数的话会舍弃小数
小到大,直接转,大到小,强制转,浮变整,小数没
浮点数整数运算会发生运算不准确

       2进制

第一位表示数值的正数或者负数;
0表示正数
1表示负数
进制前缀
ob 属于2进制的前缀
0 这属于8进制的前缀
ox 这属于16进制的前缀
\u 这属于char类型的前缀
char属于16进制

   标识符注意

开头和结尾一般用字母
可以用下划线,美元符号,字母,数字
严禁使用拼音与字母混合,纯拼音也要避免
不可以使用java的关键字
见名之意
运算符:

扩展运算符:
+=,-=,*=,/=,%=;
注意:扩展运算符会自动发生强转!
字符串连接有同化作用
算数运算符:
+, -, *, /, ++, --, %
注意:只有++或者–会对变量的值产生影响,普通的运算符不会对改变变量的值
++或者–在后不会对本次打印产生影响.
关系运算符:
< ,>,>=,<=,==,!=
运算的结果只有一种类型:boolean类型
逻辑运算符:
,&,&&,||,|,!.
| 与 &:不短路,两边都会执行,
&&:两边都为真则为真,看见false则false;

||:有真则为真,见ture则ture;
!:取反,非真则假,非假为真
注意:||或者&&会造成语句短路
（三目运算符）条件运算符:
三目运算符:1?2:3;
如果1的表达式为true,则结果取2号位的值
如果结果为false,结果取3号位的值;
定义一个变量来保存最大值
语法:boolean表达式?表达式1:表达式2
如果表达式结果为ture,则整个表达式的结果为表达式1;
如果表达式的结果为flose,则整个表达式的结果为表达式2的.

      分支结构

1.if语句 :用于一条路结构
2.If…else结构:用于两条路结构
3.if…else if结构:用于多条路结构
先判断在执行
语法:
if(boolean-1){
语句块1
}else if(boolean-2){
语句块2
}else if(boolean-3){
语句块3
}else{
语句块4 //以上条件都不满足,最后执行的代码
}

4.Switch…case结构:
switch (){
case1:满足了情况的代码
case2:
default:
}
优点:结构清晰简单,执行效率高
缺点:只能判断整数相等,常常与break一起使用,当成功匹配到后会往后输出所有的,一直到遇到break结束
只支持int short byte char String(1.7)的数据
default:结束输出的语句
break 为结束语句

    循环结构;

三要素:
1循环变量的初始化
2 循环的条件
3 循环变量的改变
三种结构:
1.While
语法:while(循环条件Boolean){
语句块循环体
}
先判断在执行,如果不满足判断条件就不会执行

2.do…while
语法:do{
语句块
}while(boolean)

比较while与do…while:
While结构是先判断后执行;
do…while结构是先执行后判断,至少执行一次

3.for
语法:for(要素1;要素2;要素3){
语句块:反复执行的代码
}
break:用在循环中,也可以用在switch中,用于跳出当前循环结构
continue:只能用在循环中,用于跳过剩下的语句直接进行到下一次循环
注意:只能用在循环结构中,循环里面后面不能再写上代码
嵌套for循环
常用于各种方法的实现.还可以打印各种图形
语法
for(1,2,3){ //外循环
for(1,2,3){ //内循环
}
}
特点:
外循环执行一次,内循环执行多次
外循环控制行,内循环控制列 ;横着为行,数着为列

总结:
相同点:就是都可以解决重复执行的问题
不同点:
for(开始位置;循环条件;更改条件){循环体}
要求:知道开始位置,要循环多少次,变化的规律
while(判断条件){循环体}
要求:知道循环的条件,满足就执行,不满足就不执行
do{循环体}while(判断条件);
要求:知道循环条件,满足就执行;但是循环体先无条件执行一次
死循环:配合break来结束循环

变量
成员变量位置是方法外类里有效,并且有默认值;
局部变量位置是在自己方法里有效,并且用时必须初始化;
变量使用的原则:就近原则,自己方法里面有会先找自己方法里的局部变量使用,前提就是局部变量与成员变量重名时;

         数组 英文名(Array)

数组就是一种引用数据类型,可以用来存储一组数据;是可以用于存储多个相同类型数据的集合
英文叫Array 标志是[]
每个元素都有下标;数组元素的下标是从0开始的:{0.1.2.3.4.5};
案例:
声明整形数组a,包含4个元素,每个元素都是int型,默认值为0;
int[] a = new int[4];
数组的初始化:
案例:
//动态初始化------需要指定数组的长度
1.int[] a = new int[4];//4个元素默认值都是0
//静态初始
2.int[] a = {1,2,3,4};//将4个元素修改
3.int[] a = new int[]{1,2,3,4}//直接定义4个元素为1,4,5,7

3.int[] a;
a = new int[]{1,2,3,4}
生成数组内存中干的活:
在内存中开辟一个数组长度的空间
给每个元素完成初始化
给分配唯一的地址值
在内存中开辟空间存放引用类型的数据名
把地址值交给引用数据类型的数据名来保存

数组的访问
可以通过(数组.length)来获取数组的长度

数组的遍历
案例:
int[] a = new int[10];
for(int i=0;i<a.length;i++){
a[i] = 100;//给每个元素赋值为100
System.out.println(a[i]);//输出每个元素的赋值
数组的工具类arrays
概述:专门为数组提供了很多方法
常用方法
Arrays.tostring--------输出数组里的数据 ;

数组的复制
Java中提供了两种复制方式
1.java中提供了system.arraycopy()来进行复制
案例:

2.java中提供了arrays类,其中copyof()方法可以实现数组的复制,注意需要提前inport arrays类.同时借助copyof()方法可以实现数组的扩容
案例:
copyof(原数组的名字,复制几个元素);如果容量比以前的数组大;叫扩容,如果小叫缩容;
Arrays.copyofRange(原数组名,开始的位置,结束的的位置);
复制需要用一个新的数组接收 原因:数组

数组的排序
Java中提供了arrays类,其中sort()方法可以实现数组的排序,注意需要提前
导入import arrays类

sort();为数组排序---------默认是升序;

案例:

方法
方法的定义包括5要素:
修饰词 返回值类型 方法名(参数){
方法体
}
方法的调用
1对于无返回值的方法,直接调用即可
2对于有返回值的方法,常常调用时应该声明对应类型的变量来接收
return的用法:
1.return值;
(1)结束方法的执行
(2)返回结果给调用方--------用在有返回值的方法中
2.return; 直接结束方法的执行--------用在无返回值的方法中

                    对象和类

面向对象指的是以对象为核心来思考,解决问题,主要有三大特征:
1封装:
1)类:封装的都是对象的属性和行为
2)方法:封装的是对象具体的业务逻辑功能实现
3)访问控制修饰符:封装具体的访问权限.
2继承:
(1)作用:代码复用
(2)超类:所有派生类共有的属性与行为
接口:部分派生类所共有的属性与行为
派生类:派生类所持拥有的属性与行为
(3)单一继承一个超类,多接口实现,具有传递性
3多态:
(1)意义:行为多态(所有抽象方法都是多态的)
对象多态(所有对象都是多态的)
(2)向上造型.强制类转换.instanceof判断
(3)多态的表现形式:
1行为多态:因方法的重写而多态
2 对象多态:因向上造型而多态

如何创建类:
Java中是通过class来创建类的,是一类事物的抽象
如何创建对象:
Java中是通过new来创建对象的
先在类中定义属性然后在创建对象:
案例:创建学生对象
类名 定义名 = new 类名
如何访问成员
在java中可以通过引用打点来访问类中的成员
案例:

方法的签名:
在java中,方法的签名是指的方法名+参数列表
注意:与返回值类型无关

   访问权限(封装)

封装的总结:
通过private关键字,实现封装,提高了资源的安全性
当属性被private后,需要提供public的getxxx()
public: 公共的 ,所有类都可以访问
private :私有的,表示仅能在自己类中访问,别的类不能用
被封装的方法可以放到同一类的方法中,让外边的的类调用这个方法来间接访问这个被封装的方法;
default: 包访问权限,在自己包内可以随意访问,不常用.
常用的就只有public与private

方法的重载
方法的重载也被称为overload有以下两点说明:
1.发生在同一类中,方法名相同,参数列表不同,方法体不同
2.编译器在编辑中会根据方法的签名自动绑定调用的方法
案例:

构造方法

有以下5点说明:
1.给成员变量赋值
2.与类同名没有返回值类型
3.在创建new对象事自动被调用
4.若不自己写构造方法则编译器会自动送你一个无参数的构造方法,若自己写了,那么将不再提供
5.构造方法可以重载
如果把构造方法封装起来,那么外界就不能用了

构造代码块: 提取构造方法的共性代码位置是类里方法外
局部代码块:作用是控制变量的租用范围位置是方法里
执行顺序
当创建对象时先执行构造代码块在执行构造方法
当调用方法时才会去执行

案例:

this 关键字
概述
this相当于帮你创建了 一个本类的对象
this可以调用同一类中的所有资源(成员变量,方法,构造方法)
第一个方式是可以用来区别同名的成员变量与局部变量,this调用的是成员变量
第二个场景是构造方法间互相调用,但是必须要写在第一行
1.this.成员变量名:用于访问成员变量,当成员变量与局部变量重名时,这个this绝对不能省
2.this方法名():用于调用方法
3.this():用于构造方法中调用构造方法一般不常用,this只能写在第一行
Null与nullpolbterExceptlon:
Null表示空,没有指向任何对象.

访问控值符
public 类 包 子类 任意
protected 类 包 子类
default 包 类
private 类

引用类型的数组
指的是元素类型为引用类型的数组
案例:

         继承

作用:就是子类可以自动拥有父类中除了私有内容外的其他所有内容
语法:public class 子类 extends 父类
继承多用于功能的修改,子类可以拥有父类的功能,并且进行拓展
继承就是子类继承父类中的属性与方法
但是构造方法不能被继承

案例:

注意:
在派生类的构造方法中若自己没有调用超类的构造方法,则默认super()调用超类中的无参数构造方法
Super()调用超类 构造,必须位于派生类构造方法的第一行
Super关键字
Super可以在子类中获取到父类的内容;包括成员变量,方法与构造方法
super表示对父类对象 的一个引用
案例:

注意:还可以调用父类中的构造方法,必须写在子类构造方法的第一行,如果父类的构造方法是没有参数的可以不写,如果是父类中没有无参数的必须写super
继承都是向上继承的:超类中不可以访问派生类中的内容
方法的重写
子类对父类提供的方法重新定义 英文名:override

语法:子类和父类中的方法的声明完全一致,还要有足够的权限
重写又被称为方法的覆盖
重写遵循:

1 方法名相同,
2 参数列表相同
3 派生类的的返回值类型是要小于或者等于超类方法的
[1]void 时,必须相同
[2]基本类型时必须相同
[3]引用类型时,小于或者等于
4 派生类方法抛出的异常小于 或者等于超类中的方法的
5 派生类方法的访问权限是要大于或者等于超类中的方法的
案例:

重写与重载的区别

重写:
发生在子类中,方法名相同,参数列表相同,方法体不同
重载:
发生在同一类中,方法名相同,参数列表不同,方法体不同
案例:

Static
:表示静态;优先于对象产生;是属于类的;
可以通过对象+类名访问
static 资源是共享的 如果一个改变,另一个也会跟着改变;
普通资源可以调用所有资源.静态的只能调用静态的资源,不能直接调用普通资源

静态代码块:
也是拥有static的关键字的所有特点
静态代码块在成员位置static { **** }
静态代码块用于项目的初始化

getter 和setter
使用的前提:
成员变量一般使用private来声明,
用来保护成员变量不被胡乱的赋值

setter:主要是给成员变量赋值,做一定的保护
getter:从成员变量中获取数据.

补充:在ide软件中可以直接调出使用,
空白位置右键>generate>getter and setter>全选>ok;

    多态

同一个对象拥有多种形态
作用:把不同的数据类型进行统一,让程序具有超强的可扩展性

小知识点:
1把子类 的对象赋值给父类的变量>—向上转型
缺点:屏蔽掉子类中特有的方法
2 把父类中的变量转化为子类的变量>-----向下转型
向下转型可能有风险,Java中必须要求写强制类型转换
(转换之后的数据类型)变量名

final 常量
final 修饰的变量不可以被改变,所以又被称为常量
被final 修饰的方法不可以被重写
被final 修饰的类不可以被继承

final总结:就是不可变的最终的

  抽象

在Java 中:只声明,不实现

抽象方法:使用abstract来修饰,不可以有方法体,直接用分号结束
抽象类: 如果这个类中有抽象方法,这个类必须是一个抽象类,前面必须加abstract来修饰
特点: 1.抽象类不可以创建对象
2.抽象类的子类必须重写父类中的抽象方法,否则,子类也是一个抽象类
作用:通过抽象类可以强制要求子类中必须拥有哪些方法
注意:抽象类中可以有 正常的方法 ,抽象类是具有多态性的

       接口

接口实际上是一种特殊的抽象类
接口中所有的方法都是抽象方法
接口使用 interface来声明
接口里面是没有变量的,而是简写的静态常量
接口里面可以写静态 static 的方法或者 是默认的default 的方法;
注意:但是是在jdk1.8以后才提供的
接口没有抽象方法,没有变量,只有常量,有抽象方法和普遍方法(jdk.1.8)以后
实现类实现了接口需要重写里面的所有抽象方法

类只能够单继承,接口可以多实现,多继承,还可以继承时多实现;
打个比方说:这个类继承了一个父类,还可以来用inplements 来支持多个接口

接口是同样拥有多态性的
接口可以把很多 不相关的内容进行整合

特点;
1.接口中所有的方法都是抽象方法,而且全部都是公开的
2.接口中所有的变量都是全局静态常量

          内部类

成员内部类:
1内部套类,外面的称为外部类,里面的称为内部类
2 内部类通常只服务于外部类,对外不具有可见性
3内部类中的对象只能在外部类中创建
4 内部类中可以直接访问外部类中的成员(包括私有的)
注意:内部类中有个隐式的引用指向了创建他的外部类对象(外部对象名.this)

匿名内部类:
作用:简化代码
语法: 创建一个新对象后面加上大括号
就被称为匿名内部类,里面可以写类体
调用里面的方法时就可以直接(对象名.方法名)就可以调用
1若想创建一个类(派生类)的对象,并且对象只创建一次,此时该类不必命名,称为匿名内部类
2匿名内部类中不能够修改外面变量的值,因为此处默认该变量一定是final 的

              内存管理

堆:
1存储new出来的对象(包括实际变量)
2 垃圾:没有任何引用所指向的对象
(1)垃圾回收器(GC)会不定时到内存堆中清理垃圾
(2)垃圾回收过程是看不到的,不一定一发现垃圾就回收
(3)可以通过调用system.gc()建议虚拟机尽快调度回收
3 内存泄漏:不在使用的内存还没有及时的回收,严重的泄漏会导致系统的崩溃
建议:不在使用的对象及时将引用设置为null
4 实例变量的生命周期:创建对象时存储在堆中,对象被回收时一并被回收

栈:
1.存储的是正在调用的方法中的局部变量(包括参数)
2.调用方法时,会在栈中为该方法分配一块对应的栈帧;栈帧中存储方法中的局部变量(包括参数);
方法使用结束后,栈帧自动清除,局部变量一并被清除
3 生命周期:调用方法时存储在栈中,方法结束时一并被清除

方法区:
1 方法区存储的是.class字节码文件(包括静态变量,方法)
2 方法只有一份
面向对象总结
面向对象指的是以对象为核心来思考,解决问题,主要有三大特征:
1封装:
4)类:封装的都是对象的属性和行为
5)方法:封装的是对象具体的业务逻辑功能实现
6)访问控制修饰符:封装具体的访问权限.
2继承:
(4)作用:代码复用
(5)超类:所有派生类共有的属性与行为
接口:部分派生类所共有的属性与行为
派生类:派生类所持拥有的属性与行为
(6)单一继承一个超类,多接口实现,具有传递性
3多态:
(1)意义:行为多态(所有抽象方法都是多态的)
对象多态(所有对象都是多态的)
(2)向上造型.强制类转换.instanceof判断
(3)多态的表现形式:
1行为多态:因方法的重写而多态
2 对象多态:因向上造型而多态

异常：
1、Throwable下有个异常子类：error和execption。
Error:是不能靠程序能处理的，比如：内存溢出。
Exception:运行时异常（非检查异常）和非运行时异常（检查异常）
2、常见的运行时异常：
1）    NullPointerException(空指针异常)当操作一个空引用抛出的一个异常
2）    NumberFormatException(数据格式化异常)试图将字符串转换为一种数值类型时，但字符串转换不适当出现的异常。
3）    ClassCastException（类型转换异常）强制类型转换不匹配时出现的异常。
4）    ArrayIndexOutOfBoundsExveption(数组下标越界异常)：当使用一个不存在的下标时出现的异常。
5）    ArithmeticException(数字异常)：异常运算条件时出现的
非运行时异常：
1）    SQLException:访问数据库时出现的
2）    IOException :当发生某种I/O异常时抛出的
3）    ClassNotFoundException:当应用程序使用Class类中的forName方法、loadClass方法时，抛出的异常。
3、在JAVA语言中，如何引发异常？对异常处理的途径？
在java中可以使用throw来引发异常。
1）    使用throws抛出异常，
2）    使用try-catch语句捕获异常。
（当调用一个含有throws声明异常抛出的方法时，编译器要求必须处理这个异常， 而处理方式有两种:
             1:使用try-catch处理该异常
             2:在当前方法上继续声明throws将该异常
        抛出）

4、名词解释：
Try:用来指定一块预防所有异常的程序，
Catch字句紧跟在try后面，用来指定想要捕获的异常
Throw语句用来明确抛出一个异常
  Throws用了标明这个方法可能会抛出的各种异常  try{}catch()finally{}
  finally块是异常捕获机制中的最后一块。
  finally可以直接跟在try后面或者最后一个catch之后。
  finally可以保证只要程序执行到try语句块中，无论
  try语句块中的代码是否抛出异常，finally块中的代码
  都必定执行。
 注意： 通常会将无论是否出现异常都要运行的代码放在 finally中确保运行，比如IO操作中的关闭流。
 Final是一个修饰符。
   Finalize是方法名，此方法是在垃圾回收器将对象从内存中清除之前做必要的清理工作。

5、派生类在继承超类时会重写其方法，那么在重写超类
  中含有throws声明异常抛出的方法时，对throws的重写规则：
1)可以不再抛出任何异常
    2)可以仅抛出父类方法抛出的部分异常    
    3)可以抛出父类方法抛出异常的子类型异常
4)不允许抛出额外异常
5)不允许抛出父类方法抛出异常的父类型异常

集合
集合与数组的比较
数组的好处：查询高效，
数组的缺点：