1.面向对象和面向过程的思想对比

​ 面向过程：是一种以过程为中心的编程思想，实现功能的每一步，都是自己实现的

​ 面向对象：是一种以对象为中心的编程思想，通过指挥对象实现具体的功能

2.类和对象的关系

客观存在的事物皆为对象 ，所以我们也常常说万物皆对象。

2.1 类

  • 类的理解
    • 类是对现实生活中一类具有共同属性和行为的事物的抽象
    • 类是对象的数据类型，类是具有相同属性和行为的一组对象的集合
    • 简单理解：类就是对现实事物的一种描述
  • 类的组成
    • 属性：指事物的特征，例如：手机事物（品牌，价格，尺寸）
    • 行为：指事物能执行的操作，例如：手机事物（打电话，发短信）

2.2 类和对象的关系

  • 类：类是对现实生活中一类具有共同属性和行为的事物的抽象
  • 对象：是能够看得到摸的着的真实存在的实体
  • 简单理解：类是对事物的一种描述，对象则为具体存在的事物

3.类的定义

类的组成是由属性和行为两部分组成

  • 属性：在类中通过成员变量来体现（类中方法外的变量）
  • 行为：在类中通过成员方法来体现（和前面的方法相比去掉static关键字即可）

类的定义步骤：

​ ① 定义类

​ ② 编写类的成员变量

​ ③ 编写类的成员方法

1
2
3
4
5
6
7
8
9
10
11
12
public class Student {
    // 属性 : 姓名, 年龄
    // 成员变量: 跟之前定义变量的格式一样, 只不过位置发生了改变, 类中方法外
    String name;
    int age;

    // 行为 : 学习
    // 成员方法: 跟之前定义方法的格式一样, 只不过去掉了static关键字.
    public void study(){
        System.out.println("学习");
    }
}

4.对象的创建和使用

  1. 创建对象的格式：
1
类名 对象名 = new 类名();
  1. 调用成员的格式：
1
2
对象名.成员变量;
对象名.成员方法();
  1. 示例代码：
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
package com.itheima.object1;

public class TestStudent {
    /*
        创建对象的格式:
                类名 对象名 = new 类名();
        调用成员变量的格式:
                对象名.变量名
        调用成员方法的格式:
                对象名.方法名();
     */
    public static void main(String[] args) {
        // 类名 对象名 = new 类名();
        Student stu = new Student();
        // 对象名.变量名
        // 默认初始化值
        System.out.println(stu.name);  // null
        System.out.println(stu.age);   // 0

        stu.name = "张三";
        stu.age = 23;

        System.out.println(stu.name);  // 张三
        System.out.println(stu.age);   // 23

        // 对象名.方法名();
        stu.study();
        // com.itheima.object1.Student@b4c966a
        // 全类名(包名 + 类名)
        System.out.println(stu);
    }
}

5.对象内存图

5.1 单个对象内存图

1590938666222

5.2 多个对象内存图

1590938693756

总结：

多个对象在堆内存中，都有不同的内存划分，成员变量存储在各自的内存区域中，成员方法多个对象共用的一份

5.3 多个对象指向相同内存图

1590938711726

总结 :

  • 当多个对象的引用指向同一个内存空间（变量所记录的地址值是一样的）

  • 只要有任何一个对象修改了内存中的数据，随后，无论使用哪一个对象进行数据获取，都是修改后的数据。

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

  1. 类中位置不同：成员变量（类中方法外）局部变量（方法内部或方法声明上）
  2. 内存中位置不同：成员变量（堆内存）局部变量（栈内存）
  3. 生命周期不同：成员变量（随着对象的存在而存在，随着对象的消失而消失）局部变量（随着方法的调用而存在，醉着方法的调用完毕而消失）
  4. 初始化值不同：成员变量（有默认初始化值）局部变量（没有默认初始化值，必须先定义，赋值才能使用）

7.封装

  • 封装概述
    是面向对象三大特征之一（封装，继承，多态）
    是面向对象编程语言对客观世界的模拟，客观世界里成员变量都是隐藏在对象内部的，外界是无法直接操作的
  • 封装原则
    将类的某些信息隐藏在类内部，不允许外部程序直接访问，而是通过该类提供的方法来实现对隐藏信息的操作和访问
    成员变量private，提供对应的getXxx()/setXxx()方法
  • 封装好处
    通过方法来控制成员变量的操作，提高了代码的安全性
    把代码用方法进行封装，提高了代码的复用性

7.1 private关键字

  1. ​ 概述 : private是一个修饰符，可以用来修饰成员（成员变量，成员方法）
  2. ​ 特点 :
    • 被private修饰的成员，只能在本类进行访问，针对private修饰的成员变量，如果需要被其他类使用，提供相应的操作
    • 提供“get变量名()”方法，用于获取成员变量的值，方法用public修饰
    • 提供“set变量名(参数)”方法，用于设置成员变量的值，方法用public修饰
  3. ​ 示例代码：
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
/*
    学生类
 */
class Student {
    //成员变量
    private String name;
    private int age;

    //get/set方法
    public void setName(String n) {
        name = n;
    }

    public String getName() {
        return name;
    }

    public void setAge(int a) {
        age = a;
    }

    public int getAge() {
        return age;
    }

    public void show() {
        System.out.println(name + "," + age);
    }
}
/*
    学生测试类
 */
public class StudentDemo {
    public static void main(String[] args) {
        //创建对象
        Student s = new Student();

        //使用set方法给成员变量赋值
        s.setName("林青霞");
        s.setAge(30);

        s.show();

        //使用get方法获取成员变量的值
        System.out.println(s.getName() + "---" + s.getAge());
        System.out.println(s.getName() + "," + s.getAge());

    }
}

7.2 this关键字

  1. 概述 : this修饰的变量用于指代成员变量，其主要作用是（区分局部变量和成员变量的重名问题）

  2. 注意：

    -
    方法的形参如果与成员变量同名，不带this修饰的变量指的是形参，而不是成员变量

    -
    方法的形参没有与成员变量同名，不带this修饰的变量指的是成员变量

  3. 代码实现 :

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
public class Student {
    private String name;
    private int age;

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

    public String getName() {
        return name;
    }

    public void setAge(int age) {
        this.age = age;
    }

    public int getAge() {
        return age;
    }

    public void show() {
        System.out.println(name + "," + age);
    }
}

7.2.1 this内存原理

注意 : this代表当前调用方法的引用，哪个对象调用的方法，this就代表哪一个对象

图解 ：

1590938942838

1590938969305

8.构造方法

8.1 注意

  1. 方法名与类名相同，大小写也要一致
  2. 没有返回值类型，连void都没有
  3. 没有具体的返回值（不能由retrun带回结果数据）

8.2 执行时机

  • 创建对象的时候调用，每创建一次对象，就会执行一次构造方法
  • 不能手动调用构造方法

8.3 作用

​ 用于给对象的数据（属性）进行初始化

8.4 构造方法的注意事项

  • 构造方法的创建 :

    ​ 如果没有定义构造方法，系统将给出一个默认的无参数构造方法

    ​ 如果定义了构造方法，系统将不再提供默认的构造方法

  • 推荐的使用方式 :

    ​ 无论是否使用，都手动书写无参数构造方法，和带参数构造方法

9.一个标准的类案例

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
package com.itheima.test3;

/*
    JavaBean类: 封装数据
 */
public class Student {
    private String name;
    private int age;

    public Student() {
    }

    public Student(String name, int age) {
        this.name = name;
        this.age = age;
    }

    public String getName() {
        return name;
    }

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

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

    public void show(){
        System.out.println(name + "..." + age);
    }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
package com.itheima.test3;

public class TestStudent {
    public static void main(String[] args) {
        // 1. 无参数构造方法创建对象, 通过setXxx方法给成员变量进行赋值
        Student stu1 = new Student();
        stu1.setName("张三");
        stu1.setAge(23);
        stu1.show();

        // 2. 通过带参数构造方法, 直接给属性进行赋值
        Student stu2 = new Student("李四",24);
        stu2.show();
    }
}

10.static关键字

static 关键字是静态的意思,是Java中的一个修饰符,可以修饰成员方法,成员变量

10.1 static修饰的特点

  • 被类的所有对象共享

    是我们判断是否使用静态关键字的条件

  • 随着类的加载而加载，优先于对象存在

    对象需要类被加载后，才能创建

  • 可以通过类名调用

    也可以通过对象名调用

10.2 static关键字注意事项

  • 静态方法只能访问静态的成员
  • 非静态方法可以访问静态的成员，也可以访问非静态的成员
  • 静态方法中是没有this关键字

11. 继承

继承是面向对象三大特征之一，可以使得子类具有父类的属性和方法，还可以在子类中重新定义，以及追加属性和方法

11.1 继承的实现

格式：

1
2
class 子类 extends 父类 { } 
class Dog extends Animal { }

继承的作用：继承可以让类与类之间产生关系，子父类关系，产生子父类后，子类则可以使用父类中非私有的成员。

示例代码：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
public class Fu {
    public void show() {
        System.out.println("show方法被调用");
    }
}
public class Zi extends Fu {
    public void method() {
        System.out.println("method方法被调用");
    }
}
public class Demo {
    public static void main(String[] args) {
        //创建对象，调用方法
        Fu f = new Fu();
        f.show();

        Zi z = new Zi();
        z.method();
        z.show();
    }
}

11.2 继承的好处和弊端

  • 好处
    • 提高了代码的复用性(多个类相同的成员可以放到同一个类中)
    • 提高了代码的维护性(如果方法的代码需要修改，修改一处即可)
  • 弊端
    • 继承让类与类之间产生了关系，类的耦合性增强了，当父类发生变化时子类实现也不得不跟着变化，削弱了子类的独立性
  • 应用场景：
    • 使用继承，需要考虑类与类之间是否存在is..a的关系，不能盲目使用继承
    • is..a的关系：谁是谁的一种，例如：老师和学生是人的一种，那人就是父类，学生和老师就是子类

11.3 继承的特点

Java中继承的特点:

  1. Java中类只支持单继承，不支持多继承。错误范例：class A extends B, C { }
  2. Java中类支持多层继承

多层继承示例代码：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
public class Granddad {
    public void drink() {
        System.out.println("爷爷爱喝酒");
    }
}

public class Father extends Granddad {
    public void smoke() {
        System.out.println("爸爸爱抽烟");
    }
}

public class Mother {
    public void dance() {
        System.out.println("妈妈爱跳舞");
    }
}

public class Son extends Father {
	// 此时，Son类中就同时拥有drink方法以及smoke方法
}

11.4 继承中的成员访问特点

11.4.1 继承中变量的访问特点

在子类方法中访问一个变量，采用的是就近原则。

子类局部范围找—— >子类成员范围找—— >父类成员范围找—— >如果都没有就报错(不考虑父亲的父亲…)

示例代码:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
class Fu {
    int num = 10;
}
class Zi {
    int num = 20;
    public void show(){
        int num = 30;
        System.out.println(num);
    }
}
public class Demo1 {
    public static void main(String[] args) {
        Zi z = new Zi();
        z.show();	// 输出show方法中的局部变量30
    }
}

11.4.2 super

  • this&super关键字：
    • this：代表本类对象的引用
    • super：代表父类存储空间的标识(可以理解为父类对象引用)
  • this和super的使用分别
    • 成员变量：
      • this.成员变量 - 访问本类成员变量
      • super.成员变量 - 访问父类成员变量
    • 成员方法：
      • this.成员方法 - 访问本类成员方法
      • super.成员方法 - 访问父类成员方法
  • 构造方法：
    • this(…) - 访问本类构造方法
    • super(…) - 访问父类构造方法

11.4.3 继承中构造方法的访问特点

注意：子类中所有的构造方法默认都会访问父类中无参的构造方法

​ 子类会继承父类中的数据，可能还会使用父类的数据。所以，子类初始化之前，一定要先完成父类数据的初始化，原因在于，每一个子类构造方法的第一条语句默认都是：super()

1
2
3
4
5
问题：如果父类中没有无参构造方法，只有带参构造方法，该怎么办呢？
1. 通过使用super关键字去显式的调用父类的带参构造方法	super(name,age);
2. 子类通过this去调用本类的其他构造方法,本类其他构造方法再通过super去手动调用父类的带参的构造方法

注意: this(…)super(…) 必须放在构造方法的第一行有效语句，并且二者不能共存

11.4.4 继承中成员方法的访问特点

通过子类对象访问一个方法

子类成员范围找—— >父类成员范围找—— >如果都没有就报错(不考虑父亲的父亲…)

11.4.5 super内存图

对象在堆内存中，会单独存在一块super区域，用来存放父类的数据

01_super内存图

11.4.6 方法重写

1、方法重写概念：子类出现了和父类中一模一样的方法声明（方法名一样，参数列表也必须一样）

2、方法重写的应用场景：当子类需要父类的功能，而功能主体子类有自己特有内容时，可以重写父类中的方法，这样，即沿袭了父类的功能，又定义了子类特有的内容

3、Override注解：用来检测当前的方法，是否是重写的方法，起到【校验】的作用

11.4.6.1 注意事项

  1. 私有方法不能被重写(父类私有成员子类是不能继承的)
  2. 子类方法访问权限不能更低(public > 默认 > 私有)
  3. 静态方法不能被重写,如果子类也有相同的方法,并不是重写的父类的方法

示例代码：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
public class Fu {
    private void show() {
        System.out.println("Fu中show()方法被调用");
    }

    void method() {
        System.out.println("Fu中method()方法被调用");
    }
}

public class Zi extends Fu {

    /* 编译【出错】，子类不能重写父类私有的方法*/
    @Override
    private void show() {
        System.out.println("Zi中show()方法被调用");
    }
   
    /* 编译【出错】，子类重写父类方法的时候，访问权限需要大于等于父类 */
    @Override
    private void method() {
        System.out.println("Zi中method()方法被调用");
    }

    /* 编译【通过】，子类重写父类方法的时候，访问权限需要大于等于父类 */
    @Override
    public void method() {
        System.out.println("Zi中method()方法被调用");
    }
}

11.4.6.2 权限修饰符

修饰符 同一个类中 同一个包中子类无关类 不同包的子类 不同包的无关类
private 可以
默认 可以 可以
protected 可以 可以 可以
public 可以 可以 可以 可以

12. 抽象类

​ 当我们在做子类共性功能抽取时，有些方法在父类中并没有具体的体现，这个时候就需要抽象类了。

​ 在Java中，一个没有方法体的方法应该定义为抽象方法，而==类中如果有抽象方法，该类必须定义为抽象类！==

12.1 抽象类的特点

抽象类和抽象方法必须使用 abstract 关键字修饰：

1
2
3
4
5
//抽象类的定义
public abstract class 类名 {}

//抽象方法的定义
public abstract void eat();

注意：

  • 抽象类中不一定有抽象方法，有抽象方法的类一定是抽象类

  • 抽象类不能实例化

  • 抽象类可以有构造方法

  • 抽象类的子类

    ​ 要么重写抽象类中的所有抽象方法

    ​ 要么是抽象类

12.2 抽象类的案例

  • 案例需求

    ​ 定义猫类(Cat)和狗类(Dog)

    ​ 猫类成员方法：eat（猫吃鱼）drink（喝水…）

    ​ 狗类成员方法：eat（狗吃肉）drink（喝水…）

  • 实现步骤

    1. 猫类和狗类中存在共性内容，应向上抽取出一个动物类（Animal）
    2. 父类Animal中，无法将 eat 方法具体实现描述清楚，所以定义为抽象方法
    3. 抽象方法需要存活在抽象类中，将Animal定义为抽象类
    4. 让 Cat 和 Dog 分别继承 Animal，重写eat方法
    5. 测试类中创建 Cat 和 Dog 对象，调用方法测试

  • 代码实现

    • 动物类
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    public abstract class Animal {
        public void drink(){
            System.out.println("喝水");
        }

        public Animal(){
        }

        public abstract void eat();
    }
    • 猫类
    1
    2
    3
    4
    5
    6
    public class Cat extends Animal {
        @Override
        public void eat() {
            System.out.println("猫吃鱼");
        }
    }
    • 狗类
    1
    2
    3
    4
    5
    6
    public class Dog extends Animal {
        @Override
        public void eat() {
            System.out.println("狗吃肉");
        }
    }
    • 测试类
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    public static void main(String[] args) {
            Dog d = new Dog();
            d.eat();//狗吃肉
            d.drink();//喝水

            Cat c = new Cat();
            c.drink();//喝水
            c.eat();//猫吃鱼

            //Animal a = new Animal();//报错：Animal是抽象的; 无法实例化
            //a.eat();
        }

12.3 final

12.3.1 fianl关键字的作用

final代表最终的意思，可以修饰成员方法，成员变量，类

12.3.2 final修饰类、方法、变量的效果

  • fianl修饰类：该类不能被继承（不能有子类，但是可以有父类）

  • final修饰方法：该方法不能被重写

  • final修饰变量：表明该变量是一个常量，不能再次赋值

    • 变量是基本类型,不能改变的是值

    • 变量是引用类型,不能改变的是地址值,但地址里面的内容是可以改变的

    • 举例：

      1
      2
      3
      4
      5
      public static void main(String[] args){
          final Student s = new Student(23);
        	s = new Student(24);  // 错误
       	s.setAge(24);  // 正确
      }

13.代码块

在Java中，使用 { } 括起来的代码被称为代码块

13.1 局部代码块

位置: 方法中定义

作用: 限定变量的生命周期，及早释放，提高内存利用率

示例代码：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
public class Test {
    /*
        局部代码块
            位置：方法中定义
            作用：限定变量的生命周期，及早释放，提高内存利用率
     */
    public static void main(String[] args) {
        {
            int a = 10;
            System.out.println(a);
        }

       // System.out.println(a);
    }
}

13.2 构造代码块

位置: 类中方法外定义

特点: 每次构造方法执行的时，都会执行该代码块中的代码，并且在构造方法执行前执行

作用: 将多个构造方法中相同的代码，抽取到构造代码块中，提高代码的复用性

示例代码：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
public class Test {
    /*
        构造代码块:
            位置：类中方法外定义
            特点：每次构造方法执行的时，都会执行该代码块中的代码，并且在构造方法执行前执行
            作用：将多个构造方法中相同的代码，抽取到构造代码块中，提高代码的复用性
     */
    public static void main(String[] args) {
        Student stu1 = new Student();
      	//好好学习	
      	//空参数构造方法
        Student stu2 = new Student(10);
      	//好好学习	
      	//带参数构造方法...........
    }
}

class Student {

    {
        System.out.println("好好学习");
    }

    public Student(){
        System.out.println("空参数构造方法");
    }

    public Student(int a){
        System.out.println("带参数构造方法...........");
    }
}

13.3 静态代码块

位置: 类中方法外定义

特点: 需要通过static关键字修饰，随着类的加载而加载，并且只执行一次

作用: 在类加载的时候做一些数据初始化的操作

示例代码：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
public class Test {
    /*
        静态代码块:
            位置：类中方法外定义
            特点：需要通过static关键字修饰，随着类的加载而加载，并且只执行一次
            作用：在类加载的时候做一些数据初始化的操作
     */
    public static void main(String[] args) {
        Person p1 = new Person();
      	//我是静态代码块, 我执行了
      	//我是Person类的空参数构造方法
        Person p2 = new Person(10);
      	//我是Person类的带...........参数构造方法
    }
}

class Person {
    static {
        System.out.println("我是静态代码块, 我执行了");
    }

    public Person(){
        System.out.println("我是Person类的空参数构造方法");
    }

    public Person(int a){
        System.out.println("我是Person类的带...........参数构造方法");
    }
}

14.接口

接口就是一种公共的规范标准，只要符合规范标准，大家都可以通用。

Java中接口存在的两个意义：用来定义规范、用来做功能的拓展

14.1 特点

接口用关键字interface修饰

1
public interface 接口名 {}

类实现接口用implements表示

1
public class 类名 implements 接口名 {}

14.2 注意

  • 接口不能实例化

    ​ 我们可以创建接口的实现类对象使用

  • 接口的子类

    ​ 要么重写接口中的所有抽象方法

    ​ 要么子类也是抽象类

14.3 成员特点

  • 成员变量

    ​ 只能是常量
    ​ 默认修饰符：public static final

  • 构造方法

    ​ 没有，因为接口主要是扩展功能的，而没有具体存在

  • 成员方法

    ​ 只能是抽象方法

    ​ 默认修饰符：public abstract

    ​ 关于接口中的方法，JDK8和JDK9中有一些新特性，后面再讲解

代码演示:

1
2
3
4
5
6
//接口
public interface Inter {
    public static final int NUM = 10;

    public abstract void show();
}
1
2
3
4
5
6
7
8
9
10
11
//实现类
class InterImpl implements Inter{

    public void method(){
        // NUM = 20;
        System.out.println(NUM);
    }

    public void show(){
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
//测试类
public class TestInterface {
    /*
        成员变量: 只能是常量 系统会默认加入三个关键字
                    public static final
        构造方法: 没有
        成员方法: 只能是抽象方法, 系统会默认加入两个关键字
                    public abstract
     */
    public static void main(String[] args) {
        System.out.println(Inter.NUM);
    }
  
}

14.4 类和接口的关系

  • 类与类的关系

    ​ 继承关系，只能单继承，不能多继承，但是可以多层继承

  • 类与接口的关系

    ​ 实现关系，可以单实现，也可以多实现，还可以在继承一个类的同时实现多个接口

  • 接口与接口的关系

    ​ 继承关系，可以单继承，也可以多继承

14.5 接口组成更新

  • 常量

    public static final

  • 抽象方法

    public abstract

  • 默认方法(Java 8)

  • 静态方法(Java 8)

  • 私有方法(Java 9)

14.5.1 接口中默认方法

作用：解决接口升级的问题

格式:

1
public default 返回值类型 方法名(参数列表) {   }

范例：

1
2
public default void show3() { 
}

注意事项：

  • 默认方法不是抽象方法，所以不强制被重写。但是可以被重写，重写的时候去掉default关键字
  • public可以省略，default不能省略
  • 如果实现了多个接口，多个接口中存在相同的方法声明，子类就必须对该方法进行重写

14.5.2 接口中静态方法

格式：

1
public static 返回值类型 方法名(参数列表) {   }

范例：

1
2
public static void show() {
}

注意事项：

  • 静态方法只能通过接口名调用，不能通过实现类名或者对象名调用
  • public可以省略，static不能省略

14.5.3 接口中私有方法

私有方法产生原因：

Java 9中新增了带方法体的私有方法，这其实在Java 8中就埋下了伏笔：Java 8允许在接口中定义带方法体的默认方法和静态方法。这样可能就会引发一个问题：当两个默认方法或者静态方法中包含一段相同的代码实现时，程序必然考虑将这段实现代码抽取成一个共性方法，而这个共性方法是不需要让别人使用的，因此用私有给隐藏起来，这就是Java 9增加私有方法的必然性

定义格式：

  • 格式1

    1
    2
    3
    4
    private 返回值类型 方法名(参数列表) {   }

    private void show() {  
    }

  • 格式2

    1
    2
    3
    4
    private static 返回值类型 方法名(参数列表) {   }

    private static void method() {  
    }

注意事项：

  • 默认方法可以调用私有的静态方法和非静态方法
  • 静态方法只能调用私有的静态方法

代码示例：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
public interface Inter {
    public default void start() {
        System.out.println("start方法执行了...");
        log();
    }

    public default void end() {
        System.out.println("end方法执行了...");
        log();
    }

    private void log(){
        System.out.println("默认方法公用部分");
    }

    private static void check(){
        System.out.println("静态方法共用部分");
    }

    public static void open() {
        check();
        System.out.println("open方法执行了");
    }

    public static void close(){
        check();
        System.out.println("close方法执行了");
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
public class TestInterface {
    public static void main(String[] args) {
        InterImpl ii = new InterImpl();
        ii.start();
      	//start方法执行了...
      	//默认方法公用部分
        ii.end();
      	//end方法执行了...
     	 	//默认方法公用部分

      	Inter.open();
				//静态方法共用部分
				//open方法执行了
        Inter.close();
        //静态方法共用部分
				//close方法执行了
    }
}

class InterImpl implements Inter {
}

15.多态

​ 同一个对象，在不同时刻表现出来的不同形态

15.1 概述

多态的前提：

  1. 要有继承或实现关系
  2. 要有方法的重写
  3. 要有父类引用指向子类对象

代码演示：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
class Animal {
    public void eat(){
        System.out.println("动物吃饭");
    }
}

class Cat extends Animal {
    @Override
    public void eat() {
        System.out.println("猫吃鱼");
    }
}

public class Test1Polymorphic {
    /*
        多态的前提:
            1. 要有(继承 \ 实现)关系
            2. 要有方法重写
            3. 要有父类引用, 指向子类对象
     */
    public static void main(String[] args) {
        // 当前事物, 是一只猫
        Cat c = new Cat();
        // 当前事物, 是一只动物
        Animal a = new Cat();
        a.eat();
      	//猫吃鱼
    }
}

15.2 多态中的成员访问特点

成员访问特点：

  • 成员变量

    ​ 编译看父类，运行看父类

  • 成员方法

    ​ ==编译看父类，运行看子类==

代码演示：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
class Fu {
    int num = 10;
    public void method(){
        System.out.println("Fu.. method");
    }
}

class Zi extends Fu {
    int num = 20;
    public void method(){
        System.out.println("Zi.. method");
    }
}

public class Test2Polymorpic {
    /*
         多态的成员访问特点:
                成员变量: 编译看左边 (父类), 运行看左边 (父类)
                成员方法: 编译看左边 (父类), 运行看右边 (子类)
     */
    public static void main(String[] args) {
        Fu f = new Zi();
        System.out.println(f.num);//10
        f.method();//Zi.. method
    }
}

15.3 多态的好处和弊端

  • 好处

    ​ 提高程序的扩展性。定义方法时候，使用父类型作为参数，在使用的时候，使用具体的子类型参与操作

  • 弊端

    ​ 不能使用子类的特有成员

15.4 多态中的转型

  • 向上转型：父类引用指向子类对象就是向上转型

  • 向下转型：子类型 对象名 = (子类型)父类引用;

代码演示：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
class Fu {
    public void show(){
        System.out.println("Fu..show...");
    }
}

class Zi extends Fu {
    @Override
    public void show() {
        System.out.println("Zi..show...");
    }

    public void method(){
        System.out.println("我是子类特有的方法, method");
    }
}

public class Test3Polymorpic {
    public static void main(String[] args) {
        // 1. 向上转型 : 父类引用指向子类对象
        Fu f = new Zi();
        f.show();
        // 多态的弊端: 不能调用子类特有的成员
        // f.method();

        // A: 直接创建子类对象
        // B: 向下转型

        // 2. 向下转型 : 从父类类型, 转换回子类类型
        Zi z = (Zi) f;
        z.method();
    }
}

15.5 转型存在的风险和解决方案

风险：如果被转的引用类型变量,对应的实际类型和目标类型不是同一种类型,那么在转换的时候就会出现ClassCastException

解决方案：用instanceof先判断再操作

使用格式：

1
变量名 instanceof 类型

通俗的理解：判断关键字左边的变量，是否是右边的类型，返回boolean类型结果

代码演示：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
abstract class Animal {
    public abstract void eat();
}

class Dog extends Animal {
    public void eat() {
        System.out.println("狗吃肉");
    }

    public void watchHome(){
        System.out.println("看家");
    }
}

class Cat extends Animal {
    public void eat() {
        System.out.println("猫吃鱼");
    }
}

public class Test4Polymorpic {
    public static void main(String[] args) {
        useAnimal(new Dog());
      	//狗吃肉
				//看家
        useAnimal(new Cat());
      	//猫吃鱼
    }

    public static void useAnimal(Animal a){  // Animal a = new Dog();
                                  // Animal a = new Cat();
        a.eat();
//      a.watchHome();//无法解析Animal中的方法watchHome

//      Dog dog = (Dog) a;
//      dog.watchHome();// ClassCastException  类型转换异常
      
        // 判断a变量记录的类型, 是否是Dog
        if(a instanceof Dog){
            Dog dog = (Dog) a;//必须强转，否则无法解析。。。
            dog.watchHome();
        }
    }

}

16.内部类

16.1 概述

在一个类中定义一个类。举例：在一个类A的内部定义一个类B，类B就被称为内部类

内部类定义格式：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
/*
	格式：
    class 外部类名{
    	修饰符 class 内部类名{
    	
    	}
    }
*/

class Outer {
    public class Inner {
        
    }
}

内部类的访问特点 ：

  • 内部类可以直接访问外部类的成员，包括私有
  • 外部类要访问内部类的成员，必须创建对象

示例代码：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
/*
    内部类访问特点：
        内部类可以直接访问外部类的成员，包括私有
        外部类要访问内部类的成员，必须创建对象
 */
public class Outer {
    private int outerNum = 10;

    public class Inner {
        public void show() {
            int innerNum = 20;
            System.out.println(outerNum);
        }
    }

    public void method() {
        Inner i = new Inner();
        i.show();
    }

    public static void main(String[] args) {
        Outer outer = new Outer();
        outer.method();//10
//        outer.show();//找不到，报错
//        System.out.println(outer.innerNum);//找不到，报错
    }
}

16.2 成员内部类

成员内部类的定义位置：在类中方法，跟成员变量是一个位置

外界创建成员内部类格式：

1
2
3
外部类名.内部类名 对象名 = 外部类对象.内部类对象;

Outer.Inner oi = new Outer().new Inner();

16.2.1 私有成员内部类：

将一个类，设计为内部类的目的，大多数都是不想让外界去访问，所以内部类的定义应该私有化，私有化之后，再提供一个可以让外界调用的方法，方法内部创建内部类对象并调用。

示例代码：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
class Outer {
    private int num = 10;
    private class Inner {
        public void show() {
            System.out.println(num);
        }
    }
    public void method() {
        Inner i = new Inner();
        i.show();
    }
}
public class InnerDemo {
    public static void main(String[] args) {
      
			//Outer.Inner oi = new Outer().new Inner();
			//oi.show();
      //私有化后就不能这么写
      
        Outer o = new Outer();
        o.method();//10
    }
}

16.2.2 静态成员内部类

静态成员内部类中的普通方法访问格式：

1
外部类名.内部类名 对象名 = new 外部类名.内部类名();

静态成员内部类中的静态方法访问格式：

1
外部类名.内部类名.方法名();

示例代码：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
class Outer {
    static class Inner {
        public void show(){
            System.out.println("inner..show");
        }

        public static void method(){
            System.out.println("inner..method");
        }
    }
}

public class Test3Innerclass {
    /*
        静态成员内部类演示
     */
    public static void main(String[] args) {
        // 外部类名.内部类名 对象名 = new 外部类名.内部类名();
        Outer.Inner oi = new Outer.Inner();
        oi.show();

        Outer.Inner.method();
    }
}

16.3 局部内部类

局部内部类定义位置：在方法中定义的类

局部内部类方式方式

  • 局部内部类，外界是无法直接使用，需要在方法内部创建对象并使用
  • 该类可以直接访问外部类的成员，也可以访问方法内的局部变量

示例代码：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
class Outer {
    private int num = 10;
    public void method() {
        int num2 = 20;
        class Inner {
            public void show() {
                System.out.println(num);
                System.out.println(num2);
            }
        }
        Inner i = new Inner();
        i.show();
    }
}
public class OuterDemo {
    public static void main(String[] args) {
        Outer o = new Outer();
        o.method();
    }
}

16.4 匿名内部类

本质：匿名内部类是一个继承了该类或者实现了该接口的子类匿名对象,可以通过多态的形式接受

前提：存在一个类或者接口，这里的类可以是具体类也可以是抽象类

代码示例:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
interface Inter{
    void method();
}

class Test{
    public static void main(String[] args){
        new Inter(){
            @Override
            public void method(){
                System.out.println("我是匿名内部类");
            }
        }.method();	// 直接调用方法
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
//匿名内部类在开发中的使用：当发现某个方法需要，接口或抽象类的子类对象，我们就可以传递一个匿名内部类过去，来简化传统的代码
/*
    游泳接口
 */
interface Swimming {
    void swim();
}

public class TestSwimming {
    public static void main(String[] args) {
        goSwimming(new Swimming() {
            @Override
            public void swim() {
                System.out.println("铁汁, 我们去游泳吧");
            }
        });
    }

    /**
     * 使用接口的方法
     */
    public static void goSwimming(Swimming swimming){
        /*
            Swimming swim = new Swimming() {
                @Override
                public void swim() {
                    System.out.println("铁汁, 我们去游泳吧");
                }
            }
         */
        swimming.swim();
    }
}

17.Lambda表达式

17.1体验Lambda表达式

函数式编程思想概述：

​ 在数学中，函数就是有输入量、输出量的一套计算方案，也就是“拿数据做操作”。

​ 面向对象思想强调“必须通过对象的形式来做事情”。

​ 函数式思想则尽量忽略面向对象的复杂语法：“强调做什么，而不是以什么形式去做”。

​ 而我们要学习的Lambda表达式就是函数式思想的体现。

代码演示：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
/*
    游泳接口
 */
interface Swimming {
    void swim();
}

public class TestSwimming {
    public static void main(String[] args) {
        // 通过匿名内部类实现
        goSwimming(new Swimming() {
            @Override
            public void swim() {
                System.out.println("铁汁, 我们去游泳吧");
            }
        });

        /*  通过Lambda表达式实现
            理解: 对于Lambda表达式, 对匿名内部类进行了优化
         */
        goSwimming(() -> System.out.println("铁汁, 我们去游泳吧"));
    }

    /**
     * 使用接口的方法
     */
    public static void goSwimming(Swimming swimming) {
        swimming.swim();
    }
}

17.2 标准格式

​ (形式参数) -> {代码块}

  • 形式参数：如果有多个参数，参数之间用逗号隔开；如果没有参数，留空即可
  • ->：由英文中画线和大于符号组成，固定写法。代表指向动作
  • 代码块：是我们具体要做的事情，也就是以前我们写的方法体内容

组成Lambda表达式的三要素：形式参数，箭头，代码块

17.3 使用前提

  • 有一个接口
  • 接口中有且仅有一个抽象方法

17.4 省略模式

省略的规则：

  • 参数类型可以省略。但是有多个参数的情况下，不能只省略一个
  • 如果参数有且仅有一个，那么小括号可以省略
  • 如果代码块的语句只有一条，可以省略大括号和分号（必须同时省略），如果有return，return也要省略掉

17.5 Lambda表达式和匿名内部类的区别

  • 所需类型不同
    • 匿名内部类：可以是接口，也可以是抽象类，还可以是具体类
    • Lambda表达式：只能是接口
  • 使用限制不同
    • 如果接口中有且仅有一个抽象方法，可以使用Lambda表达式，也可以使用匿名内部类
    • 如果接口中多于一个抽象方法，只能使用匿名内部类，而不能使用Lambda表达式
  • 实现原理不同
    • 匿名内部类：编译之后，产生一个单独的.class字节码文件
    • Lambda表达式：编译之后，没有一个单独的.class字节码文件。对应的字节码会在运行的时候动态生成