总结java学习（B站狂神说和动力节点老杜）——day06面向对象编程

面向对象编程

包和import

包机制

包机制的作用是为了方便程序的管理，不同功能的类分别存放在不同的包下。（按照功能划分，不同的软件包具有不同的功能）

1. package语句

   样式：package 公司域名后置

   package语句只允许出现在java源代码的第一行

import

1. A和B不在同一个包下，需要使用import语句
2. java.lang.*;这个包下的类不需要使用import导入
3. 位置在package之下，class语句声明之前

---

访问权限控制

种类

一共4个

public 公开

protect 保护

​ 默认

private 私有

权限范围

访问权限修饰符	本类	子类	同包	任意位置
public	√	√	√	√
protected	√	√	√
默认	√	√
private	√

public > protected > 默认 > private

修饰范围

属性(4个都能用)

方法(4个都能用)

类(public和默认可以使用，其他不行)

接口(public和默认可以使用，其他不行)

…

初识面向对象

本质

面向对象编程的本质就是：以类的方式组织代码，以对象的组织（封装）数据

三大特性

1. 封装
2. 继承
3. 多态

---

方法回顾和加深

方法的定义

1. 修饰符

   1.访问控制修饰符

   公共访问控制符public、保护访问控制符protected、缺省默认访问控制符、私有访问控制符private
   

   2.非访问控制修饰符

    抽象方法控制符abstract 、静态方法控制符static 、最终方法控制符final 、本地方法控制符native 、同步方法控制符synchronized
   

   （1）抽象方法控制符 abstract ： abstract 修饰的方法称为抽象方法。抽象方法仅有方法头，没有方法体和具体实现。

   （2）静态方法控制符 static ：用修饰符 static 修饰的方法称为静态方法。静态方法是属于整个类的类方法；而不使用static 修饰、限定的方法是属于某个具体类对象的方法。 由于 static方法是属于整个类的，所以它不能操纵和处理属于某个对象的成员变量，而只能处理属于整个类的成员变量，即 static 方法只能处理 static的域。

   （3）最终方法控制符 final ：用修饰符 final修饰的方法称为最终方法。最终方法是功能和内部语句不能更改的方法，即最终方法不能重写覆盖。final固定了方法所具有的功能和操作，防止当前类的子类对父类关键方法的错误定义，保证了程序的安全性和正确性。所有被 private 修饰符限定为私有的方法，以及所有包含在 final 类 ( 最终类) 中的方法，都被认为是最终方法。

   （4）本地方法控制符 native ：用修饰符 native 修饰的方法称为本地方法。为了提高程序的运行速度，需要用其它的高级语言书写程序的方法体，那么该方法可定义为本地方法用修饰符 native 来修饰。

   （5）同步方法控制符 synchronized ：该修饰符主要用于多线程程序中的协调和同步。
   ————————————————
   版权声明：本文为优快云博主「老鼠只爱大米」的原创文章，遵循CC 4.0 BY-SA版权协议，转载请附上原文出处链接及本声明。
   原文链接：https://blog.youkuaiyun.com/u012723673/article/details/80613557

2. 返回类型

3. break和return的区别

4. 方法名

   规范、见名知意

5. 参数列表

6. 异常抛出

方法的调用

1. 静态方法

   带有static的方法就是静态方法

   使用“类名.方法名”的方式进行调用

2. 非静态方法

   不带static的方法就是非静态方法

   使用“对象.方法名”的方式进行调用

3. 构造方法

   必须和类的名字相同

   必须没有返回值，也不能写void

4. 形参和实参

5. 值传递和引用传递

6. this关键字

---

对象的创建分析

使用new关键字创建对象

类名 变量名 = new 类名（构造方法）;

使用new关键字创建对象的时候，除了分配内存空间之外，还会给创建对象进行默认初始化以及对类中构造方法的调用。

构造方法

有参构造一旦创建，那么必须给出无参构造

一旦new Aaary，那么就会

---

面向对象三大特征

封装

1. 属性私有化，使用private关键字进行修饰
2. 对外提供set和get方法，set，get方法不能使用static修饰！！！

继承

Java中只存在单继承，不存在多继承

1. 使用extands关键字来表示子类继承父类

2. 父类的构造方法不能被子类继承
   原因：构造方法名必须与类名相同
   但是子类类名不可能与父类相同

   父类除了构造方法之外的属性和方法
   都可被子类继承，但子类不一定都能访问

   父类的public、protected修饰的属性和方法
   可以被子类访问

   父类默认修饰符修饰的属性和方法
   在同包的情况下，可以被子类访问
   不同包下，不可被子类访问

   父类的private修饰的属性和方法
   不能被子类访问

3. 在java中所有的类都直接或间接继承object类

4. static一般修饰父类，子类都存在的属性

5. 可以用“is a ”来表示的关系，那么就可以使用继承

6. 子类构造方法执行时，必然会调用父类的构造方法

多态

编译时是一种形态，编译时绑定父类的方法

运行时是另一种形态，运行时动态调用子类对象的方法

调用的方法必须是父类和子类都存在的方法

向上转型

访问子类和父类都存在的方法

Animal a1 = new Cat();

向下转型

想访问子类中特有的方法时，此时必须使用向下转型

Animal a1 = new Cat();
Cat x = (Cat) a1;

instanceof：判断对象的类型

向下转型通用写法

if(a1 instanceof Cat){
    Cat x = (Cat)a1;
    x.catchMouse;
}

类型转化异常

出现在向下转型中

Animal a1 = new Cat();
Bird x = (Bird) a1;

java.lang.ClassCastExcption:类型转换异常

方法覆盖

和多态不分家

Override子类对父类方法的重写，来适应不同的业务需求
最好将父类中的方法原封不动的复制过来，然后在进行重写

条件：

1. 方法名相同
2. 参数列表不同（个数、顺序、类型）
3. 相同的返回值类型
4. 访问权限不能更低，只能更高
5. 重写之后的方法不能比之前的方法抛出更多的异常，可以更少

结论：当子类对父类继承过来的方法进行“方法覆盖”之后，子类对象调用该方法的时候，一定执行覆盖后的方法

注意：

1. 私有方法不能覆盖
2. 方法覆盖只能是实例方法，是静态方法没有意义

this和this()

只能使用在实例方法中，this代表的是当前对象

什么时候不能省略？在实例方法中区分实例变量和局部变量时不能省略

public void srtName(String name){
    this.name = name;
}

this()作用是代码复用，出现在构造方法的第一行

super和super()

内存图

作用和this很相似，不过super()出现在构造方法第一行，目的是创建子类对象的时候，先初始化父类型特征

class A{
    public A(){
    }
}
class B extens A{
    public B(){
    }
}

同时没有this()和super()

默认会有一个super()，调用父类中无参构造方法

---

静态代码块和实例代码块

静态代码块

static{

}

在类加载的时候就已经执行了，并且只执行一次

实例代码块

{

}

在构造方法执行之前执行

修饰符

public

protected

private

static

final

一般和static连用形成常量，格式：static final PI = 3.1415926

1. 可以修饰变量、方法和类等
2. final修饰的类无法继承
3. final修饰的方法无法覆盖
4. final修饰的变量（引用）能且只能赋值一次
5. final修饰实例变量，系统不会赋默认值，要求程序员必须手动赋值

abstract

抽象类和接口

抽象类的定义

半抽象-------abstract关键字修饰，用来被子类继承的

1. 语法格式：

   [修饰符列表] abstract class 类名{

   }

2. 抽象类无法实例化，所以抽象类是用来被子类继承的

3. abstract和final不能联合使用

4. 抽象类的子类可以是抽象类吗？可以

5. 抽象类中有构造方法吗？有，抽象类是用来给子类继承的，子类对象创建的时候一般都回去调用父类的构造方法，因此抽象类的构造方法是供子类使用的

6. 抽象类不一定有抽象方法

抽象方法

没有实现的方法，没有方法体的方法

public abstract void doSome();
/*没有大括号*/

1. 没有方法体，以分号结尾
2. 具有关键字abstract
3. 抽象方法只能出现在抽象类中
4. 非抽象类继承抽象类必须将抽象方法实现，因为抽象方法不能出现在非抽象类中

接口的定义

完全抽象------可以看做是一种特殊的抽象类，只不过是完全抽象的

1. 语法格式：

   [修饰符列表] interface 接口名{

   }

   public interface A{
   }
   

2. 接口是一个引用数据类型，编译之后也是一个class字节码文件

3. 接口支持多继承，一个接口可以继承多个接口。

   public interface A extends B,C,D{
   }
   

4. 接口中只包含两部分内容，一部分是：抽象方法，一部分是：常量。

5. 因为是抽象方法，所以不能有方法体

6. 接口中的所有元素都是public修饰的，都是公开的

7. 因此，接口中的public abstract final可以省略不写

接口的实现

implements关键字修饰

interface Mymath{
}
class MyMathImp implements MyMath{
}

1. 类与类之间叫做继承，类与接口之间叫做实现，“实现"可以看做是特殊的"继承”
2. 当一个非抽象类实现接口必须实现接口中的所有方法★★★★★

interface Mymath{
    int sum(int a,int b);
}
class MyMathImp implements MyMath{
    public int sum(int a,int b){
        return a+b;
    }
}

3. 一个类可以实现多个接口，并且实现所有接口的所有方法

 class A implements B, C, D{
 }

继承和实现同时存在

extends 和 implements同时存在,extends在前，implements在后

class Pig extends Animal implements Flyable{
    
}

接口的多态使用

pbulic class Hello{
    public static void main(String[] args){
        interface myMath = new MyMathimp();
        int result = myMath.sum(1, 2);
    }
}
interface Mymath{
    int sum(int a,int b);
}
class MyMathImp implements MyMath{
    public int sum(int a,int b){
        return a+b;
    }
}

接口在开发中的作用

类似于多态在开发中的作用

---

内部类及OOP实战

匿名内部类

不需要另写类对接口进行实现，直接在调用的时候，对接口进行实现

public class Demo {
    public static void main(String[] args) {
        MyMath mm = new MyMath();
        mm.mySum(new Calculate() {
            public int sum(int a,int b) {
                return a+b;
            }
        },100, 200);
    }
}
interface Calculate{
	int sum(int a. int b);
}
class MyMath{
    public void mySum(Calculate c, int a, int b){
        System.out.println(x + "+" + y + "=" + c.sum(a,b));
    }
}
/*输出结果：100+200=300*/