WY的Java学习笔记（2） 面向对象

Day06面向对象

第一章.类和对象

1.面向对象的介绍

1.什么是面向对象:
自己的事情自己不做,找对象帮我去做事儿

面向过程:每一步都自己亲力亲为 C语言

2.为啥要使用面向对象思想:懒
开发简单点
开发中,很多的功能我们不想自己一步一步的写,很多的功能都给我们封装好了,我们直接拿来用就可以了,直接调用这个方法,我们想要的功能就直接实现了,而实现的过程,细节,我们不需要关注,我们只关注怎么用,用完能产生什么效果即可
3.什么使用面向对象:
当在一个类中想使用别的类中的成员时,我们就需要对象,然后用对象去点这个我们想要使用的成员

4.怎么用面向对象:
new 呗,点呗(new对象 用对象去调用此对象中的功能)
特殊情况:如果调用别类中的带static的成员,不能new->类名直接点

5.特点:
a.能让复杂的事情简单化
b.由执行者变成指挥者
c.更符合人类的思维逻辑

6.面向对象三大特征:
封装 继承 多态

2.类_class

1.概述:一类事物的抽象表示形式
2.定义:
属性(成员变量):
a.定义位置:类中方法外
b.有默认值:
整数:0
小数:0.0
字符:'\u0000'
布尔:false
引用:null
c.作用范围:
整个类
d.定义: 数据类型 变量名

行为(成员方法):这类事物能干啥
平常定义的方法,把static去掉,其他的一样,调用方式一样

3.对象

1.概述:一类事物的具体体现
2.使用:
a.导包: import 包名.包名.包名.类名 -> 为了找到我们要使用的类
如果两个类在同一个包下,使用时不需要导包;否则需要导包

特殊包:java.lang包 此包下的类使用时不需要导包 比如String
b.创建对象:想使用哪个类中的成员就new哪个类的对象
类名 对象名 = new 类名()
c.调用成员:想使用哪个类中的成员就用哪个类的对象去点哪个成员
对象名.成员名
对象名.成员变量名 = 值
对象名.方法名(实参)

4.匿名对象

Person p = new Person()
等号右边:new Person() 才是真正的将对象创建出来
等号左边:Person 代表的是对象的类型 p代表的是对象名

1.匿名对象:只有new,没有名字
2.写法:
new 类名()
3.注意:
如果涉及到赋值,千万不要用
如果只是想简单的调用一下方法,可以考虑用

第二章.成员变量和局部变量的区别

1.定义位置不同:(重点)
成员变量:类中方法外
局部变量:方法内部,以及参数位置
2.初始化值不同:(重点)
成员变量:是有默认值的
局部变量:没有默认值的,需要手动赋值才能使用
3.作用范围不同:(重点)
成员变量:作用于整个类
局部变量:只作用于自己所在的方法内部

4.内存位置不同:
成员变量:堆中
局部变量:栈中
5.生命周期不同:
成员变量:随着对象的创建而产生,随着对象的消失而消失
局部变量:随着方法的调用而产生,随着方法调用完毕而消失

Day07.可变参数 命令行参数 递归 对象数组

第一章.static静态关键字

1.概述:静态的,关键字
2.特点
a.被static修饰的成员随着类的加载而加载
b.被static修饰的成员由于跟着类到内存,所以优先于对象存在
c.被static修饰的成员属于类成员,不属于对象成员(成员方法,成员变量)
d.根据static所在的类创建出来的对象,都会共享这个静态成员
3.使用:
修饰成员变量: static 数据类型 变量名
修饰方法:
修饰符 static 返回值类型 方法名(参数){
方法体
return 结果
}
4.使用:
类名直接调用

static修饰成员的访问特点 总结:
1.访问非静态成员时,不管是否在同一个类中,统一调用方式: new对象调用
2.访问静态成员时,不管是否在同一个类中,统一调用方式:类名直接调用

第二章.可变参数

1.需求: 定义一个方法,实现任意个整数相加
分析:
参数的类型确定,但是个数不确定

1.定义:
数据类型...变量名
2.可变参数本质:
数组
3.使用场景:
参数的类型确定,但是个数不确定时
4.注意事项:
a.参数位置,只能写一个可变参数
b.可变参数和别的参数一起出现时,可变参数放到最后

第三章.递归

1.递归概念:
方法内部自己调用自己
递归的分类:
递归分为两种，直接递归和间接递归。
直接递归称为方法自身调用自己。
间接递归可以A方法调用B方法，B方法调用C方法，C方法调用A方法。
注意事项：
递归一定要有条件限定，保证递归能够停止下来，否则会发生栈内存溢出(因为会不断的压栈)。
在递归中虽然有限定条件，但是递归次数不能太多。否则也会发生栈内存溢出。

第四章 对象数组

数组是用来存储一组数据的容器，一组基本数据类型的数据可以用数组装，那么一组对象也可以使用数组来装。
即数组的元素可以是基本数据类型，也可以是引用数据类型。当元素是引用数据类型时，我们称为对象数组。、
注意：对象数组，首先要创建数组对象本身，即确定数组的长度，然后再创建每一个元素对象，如果不创建，数组的元素的默认值就是null，所以很容易出现空指针异常NullPointerException。

第七章.方法参数

1.基本数据类型做方法参数传递

基本类型作为方法参数传递的时候
传递的是值,不是变量本身
一个方法内部的局部变量的变化,不会影响其他方法中的局部变量

2.引用数据类型做方法参数传递

1.参数为引用数据类型时,传递的是地址值
所以一个方法内部引用类型的值改变了,会影响到其他方法中的这个引用类型的值

Day08.封装+标准JavaBean+继承+代码块

第一章.封装

1.封装的介绍以及使用

1.面向对象的三个特征:[封装] 继承 多态
2.什么是封装思想:
a.为什么需要封装?封装的作用和含义?
我要用洗衣机,只需要按一下按钮就可以了.有必要了解洗衣机内部构造吗?
b.隐藏对象内部的复杂性,只对外公开简单的接口.便于外界调用,从而提高了系统的可扩展性,可维护性,安全性.通俗的说,把该隐藏的隐藏起来,把该暴露的暴露出来.这就是封装的设计思想

将细节隐藏起来,对外提供一个暴露的接口,供我们使用者使用,我们只需要调用这个接口,接口中的细节(代码)就执行起来了

3.权限修饰符:private(私有的)

4.使用:
修饰成员变量:private 数据类型 变量名 -> 别的类即使new了对象也不能使用
修饰方法: 将原来方法的public 换成 private -> 别的类即使new 了对象也不能调用

5.被private修饰的成员变量,外界彻底使用不了,所以我们需要对外暴露一个接口供外界使用
setxxx()-> 为属性赋值
getxxx()-> 获取属性值

2.this的介绍

1.this:关键字,代表的是当前对象
2.注意:
当局部变量和成员变量重名时,遵循"就近原则",先访问局部的
3.在一个类中如何区分重名的成员变量和局部变量呢?

this this后面的变量就是成员变量
this.成员变量名

4.this代表的是当前对象,到底是具体代表哪个对象呢?
哪个对象调用的this所在的方法,this就代表哪个对象

3.构造方法

1.主要作用:创建对象
2.特点:
方法名和类名一样,而且没有返回值,连void都没有
主要是一new 构造方法会自动执行

3.1空参构造

1.格式:
类名(){
}
2.作用:
创建对象
3.特点:
每个类都有构造,空参构造即使没有手写出来,jvm会自动为此类提供一个空参构造

3.2有参构造

1.格式:
类名(参数){
为属性赋值代码
}
2.作用:
a.创建对象
b.为属性赋值
3.特点:
如果将有参构造手写出来,jvm将不再提供空参构造,所以我们需要将有参构造和无参构造都手写出来

第二章.标准JavaBean

JavaBean是 Java语言编写类的一种标准规范。符合JavaBean` 的类，要求：
（1）类必须是具体的和公共的，public class
（2）并且具有无参数的构造方法，有参构造
（3）成员变量私有化，并提供用来操作成员变量的set 和get 方法。

第三章.继承

1.什么是继承

1. 父类怎么形成的:
定义多个类之后,发现重复的代码太多了,我们没有必要每个类都要写一遍共性的代码
所以,我们定义一个类,将共性的代码抽取出来 放到这个类中,此类就是"父类",其他的类就可以直接继承这个"父类",就可以使用父类中抽取出来的共性的代码了
2.继承:更倾向于是一种代码的设计理念
3.注意:
子类可以继承父类中的私有和非私有成员
但是在子类中不能使用私有成员
4.学习继承不要从"拥有"层面去理解
要从"是否能使用"层面去理解

2.继承如何使用

1.关键字: extends

2.使用: 子类 extends 父类

3.继承中,成员变量和成员方法的访问特点

3.1 成员变量

子类和父类中的成员变量不重名:
如果是父类对象 只能调用父类中的成员
如果是子类对象 既能调用自己的,还能调用父类的
子类和父类中的成员变量重名：
如果是父类对象,调用父类中的
如果是子类对象,先调用子类中的,子类没有,找父类
继承中,成员变量通用的访问特点:
看等号左边是谁,先调用谁中的成员变量,如果子类没有,找父类

4.方法的重写

1.前提:有子父类继承关系
2.概述:子类中有一个和父类一样的方法,就是重写的方法
3.访问特点:看new的是谁,先调用谁中的方法,子类没有,找父类
4.如何去判断子类中的方法是否为重写的方法呢?
@Override->检测该方法是否为重写的方法
注意事项
1. 子类方法重写父类方法，必须要保证权限大于等于父类权限。(权限指的是权限修饰符)
public->protected->默认->private
2. 子类方法重写父类方法，返回值类型、方法名和参数列表都要一模一样。
3. 私有方法不能被重写,构造方法不能被重写

Day09.抽象 多态

第一章.继承

1.继承中构造方法的特点

1.在继承中:初始化子类对象是先初始化父类对象
2.注意:
在构造方法中的第一行默认有一个super(),super()是jvm自动提供的
super()->父类无参构造
3.super()可以在构造中手写出来,但是也必须要在第一行

2.super和this的具体使用

1.super概述:代表的是父类对象
2.使用:
调用父类构造方法: 在子类构造中 -> super()(调用父类中无参构造)
super(实参)(调用父类中有参构造)

调用父类成员变量: 在子类中写 -> super.成员变量名

调用父类成员方法: 在子类中写 -> super.成员方法名()
super.成员方法名(实参)
1.this概述:代表的是当前对象,哪个对象调用的this所在的方法,this就代表哪个对象
可以区分重名的成员变量和局部变量
2.使用:调用当前类中的成员

调用当前类的构造方法:
在当前类的构造方法中-> this()->调用当前类的空参构造
this(实参)->调用当前类的有参构造
调用当前类的成员变量
在当前类中写:this.成员变量名
调用当前类的成员方法
在当前类中写:this.成员方法名()
this.成员方法名(实参)

3.注意:如果在构造中使用this调用当前类的构造方法,我们应该将this放在构造第一行

注意:在构造中,super和this不能同时手写出来
1.如果构造中不写super,jvm默认在构造的第一行提供一个super(),如果将super在构造中手写出来,也需要在第一行写
2.构造中不会自动提供一个this(),如果想要调用当前类的构造方法,我们就需要手动将this写出来,也需要在构造第一行

3.继承的特点

1.继承只能单继承,不能多继承(一个子类只能有一个亲爹)
  class A extends B{} 对的
  class A extends B,C{}  不对的
      
2.继承能多层继承
  class A extends B{}
  class B extends C{}

3.一个父类可以都多个子类
  class A extends C{}
  class B extends C{}

第二章.代码块

2.1构造代码块

1.格式:
 {
   代码
 }
2.执行特点:
  每new一次,就会执行一次,并且是优先于构造方法执行的

2.2静态代码块

1.格式:
  static{
    代码
  }
2.执行特点:
  优先于构造方法,和构造代码块执行的,只执行一次

第三章.抽象

1.抽象的介绍

1.抽象类和抽象方法如何形成的:
将共性的内容抽取出来,但是方法无法做具体实现,方法体也就没法写,此时该方法就可以定义成抽象方法
抽象方法所在的类一定是抽象类
2.怎么理解抽象:是一种代码的"设计理念"
3.好处: 因为抽象方法抽取出来之后,可以作为一个标准,规定,凡是我的子类都必须拥有这个方法,且必须要去做具体实现
4.特点:
a.抽象方法所在的类 一定是抽象类
b.抽象类中不一定非得有抽象方法
c.子类继承父类时,需要重写父类中所有的抽象方法
d.抽象类不能new对象,只能通过new子类,去调用重写的方法
e.抽象类中可以有私有属性,构造,成员方法,静态方法,抽象方法

1.抽象关键字:abstract
2.抽象类:
public abstract class 类名{}
3.抽象方法定义:
修饰符 abstract 返回值类型 方法名(参数);
4.使用:
a.定义子类继承抽象父类
b.重写父类中抽象方法
c.创建子类对象(抽象类不能直接new)
d.调用重写的方法

2.抽象的注意事项

1.抽象类不能直接new对象,只能创建非抽象子类的对象
2.抽象类中,可以有构造方法,是供子类创建对象时,初始化父类中属性使用的
3.抽象类中可以有成员变量,构造,成员方法
4.抽象类中不一定非得有抽象方法,但是有抽象方法的类一定是抽象类
5.抽象类的子类,必须重写父类中的所有抽象方法,否则,编译无法通过.除非该子类也是抽象类

第五章.多态

1.多态的介绍

1.前提:
a.必须有子父类继承关系或者接口实现关系
b.必须有方法的重写(没有方法重写,多态没有意义)
c.父类引用指向子类对象: 父类类型 对象名 = new 子类()

double b = 10;
double b = 10L;
2.注意:
多态的情况下,不能直接调用子类特有功能-->多态的弊端

2.多态的基本使用

1.定义父类
2.定义子类继承父类,重写父类方法
3.new对象: 父类引用指向子类对象
4.调用重写方法

3.多态的条件下成员的访问特点

4.多态的好处(为什么学多态)

1.原始创建对象方式:
好处:既能调用子类特有的,还能调用重写的,还能调用从父类继承过来
弊端:当做参数传递时,扩展性差
2.多态方式:
好处:做参数传递时,扩展性强,用父类类型接受,可以接受它任何的子类对象
弊端:不能直接调用子类特有方法

5.多态中的转型

5.1向上转型

默认的:
父类引用指向了子类对象

弊端:不能直接调用子类特有方法

5.2向下转型

1.向下转型语法:
父类类型 对象名1 = new 子类对象()->向上转型

子类类型 对象名2 = (子类类型)对象名1

double b = 10;
int i = (int)b;

转型可能会出现的问题

1.注意:向下转型时容易出现的问题:ClassCastException:类型转换异常
2.原因:转型的时候等号左右两边的类型不一致
3.解决:instanceof ->专门用于判断类型的 ->结果是boolean型
4.用法:
对象名 instanceof 类型 -> instanceof前面的对象是否属于后面的类型