Java OOP

第二章

参数传递

定义类的方法

//定义类的方法
	方法名创建的时候首字母一定要小写
        
    类的方法是定义类的某种行为或功能

        语法格式:
        public 返回值类型  方法名（）{
            //方法的主体   
        }

方法的返回值

//两种情况：
        如果方法具有返回值，方法中必须使用关键字return返回值

        返回值类型为该返回值的类型
        
        return 表达式；     作用：跳出方法、返回结果

        如果方法没有返回值，返回值类型为void；

        如果有返回值，那么在调用的时候一定要做处理

方法调用

	对象名.方法名（）；

    同一个类中，互相直接调用

    不同类中，需要创建对象，再用对象.方法（）；

    有返回值方法的调用，必须对返回的结果做出处理

    方法之间允许相互调用,不需要知道方法的具体实现
    实现重用,提高效率

成员变量和局部变量

  	变量声明的位置决定变量的作用域

    变量作用域确定可在程序中按变量名访问该变量的区域

成员变量和局部变量的区别

     //成员变量是声明在整个类里面

     //局部变量是声明再方法里面


        1、作用域不同
            创建对象
                局部变量的作用域仅限于定义它的方法
                成员变量的作用域在整个类内部都是可见的

        2、初始值不同
                java会给成员变量一个初始值
                java不会给局部变量赋予初始值

        3、在同一个方法中，不允许有同名局部变量
            在不同的方法中，可以有同名的局部变量

        4、在同一个类中，成员变量和局部变量同名时，局部变量具有跟高的优先级（就近原则）

oop思想设计计算器

  // 面向对象（oo）思想

        类发的方法实现某个特定的功能，其他类不需要知道它如何实现，调用方法就可以了，
        不用重复代码！

带参方法创建和使用

	调用方法,传递的参数要与参数列表--对应

定义带参方法

   // 形参:
            在声明的时候规定好当前方法的数据类型,个数,顺序

        <访问修饰符>返回类型<方法名>(<形式参数列表>){
            //方法的主体
        }

调用带参方法

 		对象名.方法名(实参列表) 		        调用方法时传过去的叫实参                声明方法的时候叫形参                声明的时候是什么,调用的时候就是什么,不能改变  (形参与实参一一对应)

多个参数传递使用

 	 区间查找            开始位置，结束位置，要查的内容            形参：规定三个参数，第一个参数是整数，第二个参数是整数，第三个参数是字符串。（整数、整数、字符串）                        方法创建时规定的形参  和   方法调用时传入的实参必须：                                            顺序一样                                            类型一样                                            数量一样            调用方法是不用指定实参类型            形参和实参数据类型不能不一致（不能改变）            形参和实参数量必须一样            调用方法有返回值的必须进行处理

数组作为参数传递

	数组作为参数传递，就是形参声明的时候是数组

对象作为参数传递

  	可以将多个相关的信息封装成对象，    作为参数传递，避免方法有太多的参数    //对象做参数传递没看懂

总结

    类的无参的方法            1、定义类的方法必须包括                    1、方法的名称                    2、方法返回值的类型                    3、方法的主题            调用类方法的两种形式                    1、同一个类中的方法，直接使用“方法名（）”调用                    2、不同类的方法，先创建对象，再使用“对象名.方法名（）”调用            成员变量和局部变量的不同点                    1、作用域不同                    2、初始值不同                    3、在同一类中，成员变量和局部变量同名是，局部变量具有更高的优先级            带参方法定义的一般形式                    <访问修饰符>反回类型<方法名>(<参数列表>)                    {                        //方法的主体                    }

第三章

抽象和封装

抽取出类的过程

为什么要使用面向对象	
	1、世界由对象组成
    2、符合人类思维习惯
    
    
从现实中抽象出类分三步
    1、找出它的种类
    2、找出它的属性
    3、找出它的行为
    
    
 //属性:名词
 //方法:动词

面向对象的思想—————————————————————————面向对象的世界

构造方法

	访问修饰符 构造方法名（）{
	//初始化代码
	}
	//不需要有返回值
	//构造方法名必须与类名相同
	//小括号里可以指定参数
	//系统提供默认无参构造方法

	构造方法:
			没有返回值类型
                访问修饰符  方法名和类名相同  用来实例化对象
                可以快速的帮助进行初始化操作

方法和重载

//系统不再提供默认无参构造方法，但是当我们创建完有参构造方法之后，系统不在提供

	方法重载
		方法名相同
		参数数据类型或参数个数不同
		与返回值，访问修饰符无关
		
	//this关键字是对象的默认引用	，这里用于区分同名成员变量
	
	（无参构造方法后写带参构造方法形成构造方法的重载）
	带参数的构造方法
		方法的重载：
			1、方法名不同
			2、与访问修饰符和返回值类型无关
			3、参数列表不同（类型，个数，顺序）

Static关键字使用

在实例方法中不可以定义static变量

static	可以修饰（用类名打.调）
静态（属于类，可以使用类名直接调用）	属性，方法，代码块

static修饰与非static修饰的区别

	static修饰、非private修饰	非static修饰、private修饰
属性	类属性、类变量	实例属性、实例变量
方法	类方法	实例方法
调用方法	类名属性 类名.方法() 对象.属性 对象方法()	对象.属性 对象方法()
归属	类	单个对象

封装及其使用

//封装是面向对象三大特征之一
	//封装的概念
		将类的某些信息隐藏在类的内部，不允许外部程序直接访问，而是通过该类提供的方法来实现对隐藏信息的操作与访问

封装的步骤
修改属性的可见性	设为private (属性私有化(属性只能在本类中使用,跨类无法调用))
创建共有的getter/setter方法	用于属性的读写 (添加getter(取属性值)/setter(向里面传值)方法)
在getter/setter方法加入属性的控制语句	对属性值的合法性进行判断 (在getter(取属性值)/setter(向里面传值)添加规范操作（判断）)

this关键字使用

this:代表当前类的引用
this作用:
		调用成员变量，
		调用方法，
		调用构造 方法this()--->必须是构造中的第一行

总结

面向对象的思想开发程序的好处

	1、从现实世界抽象出类
			1、找出名词确定类、属性
			2、找出动词确定方法
			3、剔除与业务无关的属性和方法
	2、方法重载
    		1、方法名相同
    		2、参数项不同
    		3、与访问修饰符和返回值无关
    3、static可以修饰属性、方法、代码块
    4、实现封装的步骤
    		1、修改属性的可见性
    		2、创建共有的getter/setter方法
    		3、在getter/setter方法中加入属性控制语句

第四章 继承

继承的使用

使用继承优化设计
	将重复的代码抽取到父类中
使用继承优化后
	方便修改代码
	减少代码量
//子类与父类的关系是 is-a
继承关键字
    extends
    extends（得到父类的属性和方法)
    继承可以做到代码的复用
一个子类只能有一个父类
一个父类可以有多个子类    

继承的特点

理解继承
	子类访问父类成员
		使用super关键字,super代表父类对象
		在子类构造方法中调用且必须是在第一句
	
 super   
//子类访问父类构造方法(必须放在第一句)
	super();
     super(name);
//访问父类属性
	super.name;
//访问父类的方法
	super.print();

子类不是能继承父类所有的资源
    //不能被继承的父类成员
    	private修饰
    	子类与父类不在同包,使用默认访问权限的成员
    	构造方法(可以调用的那不可以继承)
    
访问修饰符 protected    
    可修饰属性和方法
    本类  同包  子类可以访问
    
多重继承关系的初始化顺序
    父类属性--->父类构造方法--->子类属性--->子类构造方法
    
什么时候用继承    
    符合is-a关系的设计使用继承
    将子类共有的属性和行为放到父类中
继承是代码重用的一种方式    

访问修饰符总结

访问修饰符	本类	同包	子类	其他
private	可以
默认(friendly)	可以	可以
protected	可以	可以	可以	可以
public	可以	可以	可以	可以

重写和重载

重写
	使用继承后调用print()方法只能输出父类里面的,不能输出子类里面的
	
方法重写的规则   (不能被继承的不能重写)
	方法名相同
	参数列表相同
	返回值类型相同或者是其子类
	访问权限不能严于父类
	
super关键字来访问父类的成员
	super只能出现在子类的方法和构造方法中
	super调用构造方法时，只能是第一句
	super不能访问父类的private成员

方法重载与方法重写

	位置	方法名	参数表	返回值	访问修饰符
方法重写	子类	相同	相同	相同或是其子类	不能比父类更严格
方法重载	同类	相同	不相同	无关	无关

抽象类和抽象方法

抽象类
	禁止父类实例化
    抽象方法（没有方法体）子类必须重写，除非子类也是抽象类
abstract	
    抽象方法没有方法体
	抽象方法必须在抽象类里
	抽象方法必须在子类中被实现，除非子类是抽象类
    
    abstract 也可用于方法----抽象方法
    
 final 用法  （ final 代表最终的意思）
    当前类不希望被其他类继承
    方法不希望被重写
    属性值不希望被修该
    

总结

继承
	符合is-a关系
	使用extends关键字
	代码复用

方法重写的规则
    方法名相同
	参数列表相同
	返回值类型相同或者是其子类
	访问权限不能严于父类
    
super 关键字
    super只能出现在子类的方法和构造方法中
	super调用构造方法时，只能是第一句
	super不能访问父类的private成员
    
抽象和抽象方法
    抽象类不能被实例化
	抽象类可以有0~多个抽象方法
	非抽象子类必须重写父类的所有抽象方法
    
final 修饰符
    修饰的类，不能再被继承
	修饰的方法， 不能被子类重写
	修饰的变量将变成常量，只能在初始化时进行赋值

多态

为什么要用多态

一、多态的使用

同一种操作，由于条件不同，产生的结果也不同
父类引用指向子类对象
多态
	同一个引用类型，使用不同的实例从而而执行不同的操作
	
使用多态实现思路
	三要素
		1、编写具有继承关系的父类和子类
		2、子类重写父类方法
		3、使用父类的引用指向子类的对象（声明父类new子类D）
			向上转型
				Pet pet = new Dog();------>自动类型转换

1.2两种形式

使用父类作为方法形参实现多态
使用父类作为返回值实现多态

1.2.1使用返回值实现多态

父类到子类的转换

必须转换为父类指向的真实子类类型（向下转型[强制类型转换]）

运算符 instanceof

判断对象是否属于某一个类或接口
 instanceof 通过和强制类型转换结合使用
 对象 instanceof 类或接口

多态总结

使用多态的好处

减少类中的代码量
提高代码的可扩展和可维护性

类型转换

向上转型
    	子类转为父类，自动进行类型转换
    
向下转型
    	父类转换为子类，结合 instanceof 运算符进行强制类型转换

实现多态的两种方式

使用父类作为方法形参实现多态使用父类作为方法返回值实现    

接口

接口的基本应用

子类无法继多个父类用接口

什么事接口

public interface Myinterface{
    public void foo(){
    //其他方法										{ 接口里面的方法都是抽象方法（public abstract）
    }
}

接口的特性

接口不可以被实例化
实现类必须实现接口的所有方法
实现类可以实现多个接口
接口中的变量都是静态常量（有初始值）
    //接口常作为类型使用，可以解决java中不能多继承的问题

接口编程的能力

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-emYOoSdD-1638161397215)(E:\Java\java笔记\MD文件\面向对象\第六章\QQ截图20210617104853.png)]

面向接口编程

也就是面向接口所的规定好,所约定好的一些能力的使用

一个人可以具有多项功能
一个类可以实现多个接口

接口有比抽象类更好的特性:

可以被多继承
设计和实现完全分离
更自然的使用多态
更容易搭建程序框架
更容易更换实现

接口是一种约定

程序设计时面向接口的约定而不考虑具体实现

		//体现在接口名称和注释上
				有些接口只有名称
				方法的实现方式要通过注释来约定

接口和抽象类的区别

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-zlEhOuaS-1638161397219)(E:\Java\java笔记\MD文件\面向对象\第六章\QQ截图20210617200230.png)]

抽象类和接口在使用原则上的区别

接口做系统与外界交互的窗口

接口提供服务

接口本身一旦制定，就不允许随意修改

抽象可完成部分功能实现，还有部分功能可作为系统的扩展点

面向对象设计原则

多用组合，少用继承
针对接口编程
针对扩展开放，针对改变关闭

作业和章节总结

Java中的接口

属性全都是全局静态常量
方法都是全局抽象方法
无构造方法

一个类可以实现多个接口，接口中的全部方法

抽象类属于代码复用，接口类属于代码维护程序开发

异常

异常及异常的处理

//本章任务
	算术运算处理
	使用 throw 抛出异常	
	使用 log4j 记录日志

//本章目标
	熟悉使用 try-catch-finally 处理异常
	会使用 throw 、 throws 出异常
	掌握异常及其分类
	掌握自定义异常
	使用 log4j 记录日志

java中异常处理是通过5个关键字

try	catch	finally	throw	throws

try catch	finally 一起使用，用来捕获异常

	捕获异常
try	执行可产生异常的代码
catch	捕获异常
finally	无论是否发生异常代码总能执行

throw抛出异常	throws声明异常
手动抛出异常	声明方法可能要抛出的各种异常

异常捕获

try-catch分为三种情况

//正常情况
try->后面的代码块
public void method(){
    try{
        //代码段（此处不会产生异常）
    }catch(异常类型 ex ){
        //对异常进行处理的代码块
    }
    //代码块
}

//出现异常
try->catch->后面的代码块
public void method(){
    try(){
        //代码段1
        //产生异常的代码段2
       	//代码段3
    }catch(异常类型 ex){
        //对异常进行处理的代码段4
    }
    //代码段5
}
//异常是一种特殊的对象,类型为java.lang.Exception或子类

//异常类型不匹配
try->报错，终止程序
public void method(){
    try(){
        //代码段1
        //产生异常的代码段2
       	//代码段3
    }catch(异常类型 ex){
        //对异常进行处理的代码段4
    }
    //代码段5
}
//出现的异常与catch中的不匹配，程序还是会终止

在catch块中处理异常

加入用户自定义处理异常

System.err.println("出现错误:被除数和除数必须是整数"+"除数不能为零")

调用方法输出异常信息

e.printStackTrace();

异常对象常用的方法

方法名	说明
public printStackTrace()	输出异常的栈堆信息
String getMessage()	返回异常信息描述字符串,是printStackTrace()输出信息的一部分

常见的异常类型

异常类型	说明
Exception	异常层次结构的父类
ArithmeticException	算术错误情形，如以零做除数
ArrayIndexOutOfBoundsException	数组下标越界
NullPointerException	尝试访问null对象成员
ClassNotFoundException	不能加载所需的类
IIIegalArgumentException	方法接受到非法参数
ClassCastException	对象强制类型转换出错
NumberFormatException	数字格式转换异常，如吧“abc”转成数字

Finally块处理

在try->catch->块后加入finally块

​ 是否发生异常都要去执行finally

​ 不执行的唯一情况System.exit(1);

​ System.exit(1);中断程序,退出java虚拟机

try{    }catch(){    System.exit(1);//中断程序,退出java虚拟机}finally{    }

return在catch块中不会跳过finally

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-20EBGdLu-1638161427009)(E:\Java\java笔记\MD文件\面向对象\第七章\QQ截图20210618154727.png)]

多重catch块

排列catch语句的顺序:先子类后父类
发生异常时按顺序逐个匹配
只执行第一个与异常类型匹配的catch语包

public void method(){Scanner input = new Scanner(System.in);try{//可能会出现异常的代码块，尝试执行代码      System.out.println("请输入被除数");      int num1 = input.nextInt();      System.out.println("请输入除数");      int num2 = input.nextInt();      System.out.println("结果为："+num1/num2);}catch(ArithmeticException e){//对异常进行处理的代码段System.out.println("除数不能为零");e.printStackTrace();//将堆栈中的错误信息展示出来}catch(InputMismatchException e){//对异常进行处理的代码段  System.out.println("除数不能为零");e.printStackTrace();//将堆栈中的错误信息展示出来}catch(Exception e){/*多重catch块使用,捕获父类异常的catch块不能放在第一个位置Exception:所有异常*///对异常进行处理的代码段System.out.println("除数不能为零");e.printStackTrace();//将堆栈中的错误信息展示出来}System.out.println("程序结束！");}

finally块

    public static void main(String[] args) {        Scanner input = new Scanner(System.in);        try{//可能会出现异常的代码块，尝试执行代码            System.out.println("请输入被除数");            int num1 = input.nextInt();            System.out.println("请输入除数");            int num2 = input.nextInt();            System.out.println("结果为："+num1/num2);        }catch (ArithmeticException e){//使用catch进行异常的匹配捕获 ()里面是匹配异常的对象            System.out.println("除数不能为零");            //强制结束虚拟机运行（可以将finally块终止） （状态码 0 或 1 0：程序根据需求正常结束  1：程序出现错误需要结束）            System.exit(1);            e.printStackTrace();//将堆栈中的错误信息展示出来            return;//无法终止finally,能终止finally以后的代码块        }finally {//不管try,catch是否捕获异常,都会执行代码块            System.out.println("finally代码块");        }        System.out.println("程序结束！");    }

声明和抛出异常

throws	throw
声明异常 声明异常:告诉调用者,当前方法可能会产生异常错误,可以捕获	抛出异常（主动去抛出产生一个错误信息）

声明异常的两种方法

//one    public static void show() throws Exception{        System.out.println("你好~~~");    }    public static void main(String[] args) {        try {            show();        } catch (Exception e) {            e.printStackTrace();        }    }

//two    public static void show() throws Exception{        System.out.println("你好~~~");    }    public static void main(String[] args) throws Exception{            show();    }

抛出异常的两种方法

   //不合法数字,我们就抛出异常(手动产生一个错误)        //Throw手动抛出一个错误(1.声明出去   2.异常捕获)  抛出的是异常对象        //抛出的是异常对象   throw new Exception("当前数字不合法");  小括号里是异常提示信息

    public static void main(String[] args) throws Exception{        int  num = 10;        //判断数字是否在0~10以内        if (num>=0&&num<=10){            System.out.println("这是一个合法数字");        }else{            //不合法数字,我们就抛出异常(手动产生一个错误)            //Throw手动抛出一个错误(1.声明出去   2.异常捕获)  抛出的是异常对象            //抛出的是异常对象   throw new Exception("当前数字不合法");  小括号里是异常提示信息            throw new Exception("当前数字不合法");        }    }

    public static void main(String[] args){        int  num = 10;        //判断数字是否在0~10以内        if (num>=0&&num<=10){            System.out.println("这是一个合法数字");        }else{            //不合法数字,我们就抛出异常(手动产生一个错误)            //Throw手动抛出一个错误(1.声明出去   2.异常捕获)  抛出的是异常对象            //抛出的是异常对象   throw new Exception("当前数字不合法");  小括号里是异常提示信息            try {                throw new Exception("当前数字不合法");            } catch (Exception e) {                e.printStackTrace();            }        }    }

自定义异常

异常的分类

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-vV7fqksf-1638161427012)(E:\Java\java笔记\MD文件\面向对象\第七章\QQ截图20210621233743.png)]

当JDK中的异常类型不能满足程序需要时,可以自定义异常

使用自定义异常的步骤

定义异常类(继承Throwable类 / 继承Exception / 或者RuntimeException )—> 编写构造方法,继承父类实现 -->实例化自定义异常对象 -->使用throw抛出

log4j日志记录

日志及分类

日志log	日志分类	log4j是一个非常优秀的开源日志记录工具
主要用来记录系统运行中一些重要操作信息	SQL日志、业务日志	1、控制日志的输出级别
便于监视系统运行情况，帮助用户提前发现和避开可能出现的问题或者出现问题后根据日志找到原因		2、控制日志信息输送的目的是控制台、文件等
		3、控制每一条日志的输出格式

使用logj记录日志步骤

在项目中加入log4j的JAR文件---->创建log4j.properties文件------>配置日志信息------>使用log4j记录日志信息

stdout---- 控制台输出

logfile---- 日志文件输出

###  设置log4j输出的级别（建议常用的级别：  从高到底   ERROR，WARE，INFO,DEBUG  ）   ###log4j.rootLogger=debug,stdout,logfile
### 配置控制台输出 appender:配置输出的目的地   
######  log4j的一个日志输出的配置方式，输出stdout这个日志，输出到org.apache.log4j.ConsoleAppender   ###log4j.appender.stdout=org.apache.log4j.ConsoleAppender 
### 以错误的形式输出  ###log4j.appender.stdout.Target=System.err
### 以简单的形式输出,只输出一个基本信息   ###log4j.appender.stdout.layout=org.apache.log4j.SimpleLayout
### 配置日志文件输出(灵活输出格式化的信息)  
###### 以日志记录文件的形式输出  
###log4j.appender.logfile=org.apache.log4j.FileAppender
### 这个日志记录的文件名   
###log4j.appender.logfile.File=yuntuzhilian.log
### 自定义的形式输出 
###log4j.appender.logfile.layout=org.apache.log4j.PatternLayout
### 自定义的形式输出,设置自定义输出方式 
#### %m  输出代码指定信息# %M  输出打印日志的方法名# %p  输出优先级# %F  所属的文件名# %c  输出所属的类目，类的全名# %n  输出回车换行# %d  输出日志的时间   {yyyy-mm-dd HH:mm:ss}时间的格式# %l  输出日志的出现位置，代码的行数log4j.appender.logfile.layout.ConversionPattern=%d{yyyy-mm-dd HH:mm:ss}%l %F %p [%c] %m%n

类型转换

Long.valueOf(“字符串”) 返回Long类型
Long.parseLong(“字符串”) 返回long基本数据类型

​