面向过程&面向对象

什么是面向对象

回顾方法及加深

方法定义

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
package com.oop.demo01;

//Demo01 类
public class Demo01 {
    //main 方法
    public static void main(String[] args) {

    }

    /*
    修饰符 返回值类型 方法名(...){
        //方法体
        return 返回值;
    }
     */
    //return 结束方法，返回一个结果！
    public String sayhello(){
        return "hello,world";
    }
    public void hello(){
        return;
    }
    public int max(int a,int b){
        return a>b ? a : b; //三元运算符!
    }
}

方法调用

静态方法和非静态方法

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
package com.oop.demo01;

public abstract class Demo02 {
    //静态方法 static
    Student.say();
    
    //非静态方法
    //实例化这个类 new
    //对象类型 对象名 = 对象值；
    Student student = new Student();
    student.say();
    
    
    
    //静态方法和类一起加载的
    public static void a(){
        b();
    }
    //类实例化 之后才存在
    public void b(){
        
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
package com.oop.demo01;

//学生类
public class Student {
    
    //静态方法
    public static void say(){
        System.out.println("学生说话了");
    }

    //非静态方法
    public void say(){
        System.out.println("学生说话了");
    }
}

形参和实参

1
2
3
4
5
6
7
8
9
10
11
12
13
package com.oop.demo01;

public class Demo03 {
    public static void main(String[] args) {
        //实际参数和形式参数的类型要对应
        int add = Demo03.add(1, 2);
        System.out.println(add);
    }

    public static int add (int a,int b){
        return a+b;
    }
}

值传递

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

//值传递
public class Demo04 {
    public static void main(String[] args) {
        int a = 1;
        System.out.println(a);

        Demo04.change(a);
        System.out.println(a); //1
    }
    //返回值为空
    public static void change(int a){
        a =10;
    }
}

引用传递

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
package com.oop.demo01;

//引用传递：对象，本质还是值传递
public class Demo05 {
    public static void main(String[] args) {

        Person person = new Person();
        System.out.println(person.name); //null

        Demo05.change(person);
        System.out.println(person.name); //王同学
    }

    public static void change(Person person) {
        //person是一个对象：指向的--->Person person = new Person();这是一个具体的人，可以改变属性！
        person.name = "王同学";
    }
}

    //定义了一个Person类，有一个属性：name
    class Person {
        String name;
    }

类与对象的关系

创建与初始化对象

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.oop.demo02;

//学生类
public class Student {
    //属性：字段
    String name;
    int age;

    //方法
    public void study(){
        System.out.println(this.name+"在学习");
    }
}
/*
public static void main(String[] args) {
        //类：抽象的，实例化
        //类实例化后会返回一个自己的对象！
        //student对象就是一个Student类的具体实例！
        Student xiaoming = new Student();
        Student xiaohong = new Student();

        xiaoming.name = "小明";
        xiaoming.age = 3;
        xiaohong.name = "小红";
        xiaohong.age = 5;

        System.out.println(xiaoming.name);
        System.out.println(xiaoming.age);
        System.out.println(xiaohong.name);
        System.out.println(xiaohong.age);
    }
 */

构造器

  1. 和类名相同
  2. 没有返回值

作用：

  1. new本质在调用构造方法
  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
32
33
package com.oop.demo02;

//java--->class
public class Person {

    //一个类即使什么都不写，它也会存在一个方法
    //显示的定义构造器
    String name;


    //1.使用new关键字，本质是在调用构造器
    //2.用来初始化值

    //无参构造
    public Person(){

    }

    //有参构造：一旦定义了有参构造，无参就必须显示定义
    public Person(String name){
        this.name = name;
    }

}

/*
public static void main(String[] args) {

        //new 实例化了一个对象
        Person person = new Person("along");
        System.out.println(person.name);
    }
 */

IDEA生成构造器快捷键：Alt+Insert

或者 Code—Generate

OK—生成有参构造      Select None—生成无参构造

创建对象内存分析

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
package com.oop.demo03;

public class Pet {
    public String name;
    public int age;

    //无参构造

    public void shout(){
        System.out.println("叫了一声");
    }
}



/*
public static void main(String[] args) {
        Pet pet = new Pet();

        Pet dog = new Pet();
        dog.name = "旺财";
        dog.age = 3;
        dog.shout();

        System.out.println(dog.name);
        System.out.println(dog.age);

        Pet cat = new Pet();
    }
 */

简单小结

  1. 类与对象

    类是一个模板：抽象，对象是一个具体的实例

  2. 方法

    定义、调用！

  3. 对应的引用

    引用类型： 基本类型（8）

    对象是通过引用来操作的：栈–>堆

  4. 属性：字段Field 成员数量

    默认初始化：

    数字： 0 0.0

    cahr: u0000

    boolean: false

    引用： null

    修饰符 属性类型 属性名 = 属性值！

  5. 对象的创建和使用

    • 必须使用new 关键字创造对象，构造器 Person xx = new Person();
    • 对象的属性 xx.name
    • 对象的方法 xx.sleep()

  6. 类：

    静态的属性 属性

    动态的行为 方法

封装

封装的作用：

  1. 提高程序的安全性，保护数据
  2. 隐藏代码的实现细节
  3. 统一接口
  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
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
package com.oop.demo04;

import javax.print.DocFlavor;

//类  private:私有
public class Student {

    //属性私有
    private String name; //名字
    private int id;; //学号
    private char sex; //性别
    private int age; //年龄

    //提供一些可以操作这个属性的方法！
    //提供一些public的get、set方法

    //get 获得这个数据
    public String getName(){
        return this.name;
    }

    //set 给这个数据设置值
    public void setName(String name) {
        this.name = name;
    }
    public int getId() {
        return id;
    }

    public void setId(int id) {
        this.id = id;
    }

    public char getSex() {
            return sex;
    }

    public void setSex(char sex) {
            this.sex = sex;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        if (age>120 || age<0){//不合法
            this.age = 3;
        }else{
            this.age = age;
        }
    }
}

/*
package com.oop.demo04;

import com.oop.demo04.Student;

public class Application {
    public static void main(String[] args) {
        Student s1 = new Student();
        s1.setName("王同学");
        System.out.println(s1.getName());

        s1.setAge(150);
        System.out.println(s1.getAge());
    }
}
 */

继承

  • 在Java中，所有的类，都默认直接或者间接继承Object
  • IDEA中，ctrl+H,(打开继承明细)

super

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
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
package com.oop;

import com.oop.demo05.Student;

public abstract class Application {
    public static void main(String[] args) {
        Student student = new Student();
        student.say();
        System.out.println(student.money);


        Student s = new Student();
        s.test("王");

        s.test1();
    }
}

/*
package com.oop.demo05;

//在Java中，所有的类，都默认直接或者间接继承Object
//Person 人 ： 父类
public class Person {

    public int money = 10_0000_0000;

    public Person() {
        System.out.println("Person无参执行了");
    }

    public void say(){
        System.out.println("说了一句话");
    }



    protected String name = "along";


//若下边的public换成private,私有的东西无法被继承！
    public void print(){
        System.out.println("Person");
    }


}

 */

/*
package com.oop.demo05;

//Student 学生 is 人 ：派生类 子类
//子类继承了父类，就会拥有父类的全部方法！
public class Student extends Person {

    public Student() {
        //隐藏代码：调用了父类的无参构造
        super();//调用了父类的构造器，必须要在子类构造器的第一行
        System.out.println("Student无参执行了");
    }

    private String name = "wang";

    public void test(String name){
        System.out.println(name);//王
        System.out.println(this.name);//wang
        System.out.println(super.name);//along
    }


    public void print(){
        System.out.println("Student");
    }
    public void test1(){
        print();//Student
        this.print();//Student
        super.print();//Person
    }

}
 */

/*
package com.oop.demo05;

//Teacher 老师 ： 子类
public class Teacher extends Person{

}

 */

super注意点：

  1. super调用父类的构造方法，必须在构造方法的第一个
  2. super必须只能出现在子类的方法或者构造方法中！
  3. super和this不能同时调用构造方法！

​ VS

this:

代表的对象不同：

  • this:本身调用者这个对象
  • super：代表父类对象的应用

前提：

  • this:没有继承也可以使用
  • super:只能在继承条件才可以使用

构造方法：

  • this():本类的构造
  • super():父类的构造！

方法的重写

重写都是方法的重写，和属性无关

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
package com.oop;

import com.oop.demo05.A;
import com.oop.demo05.B;

public class Application {
    //静态的方法和非静态的方法区别很大！
    //静态方法：方法的调用只和左边定义的数据有关
    //非静态：重写
    public static void main(String[] args) {

        A a = new A();
        a.test();

        //父类的引用指向了子类
        B b = new A();//子类重写了父类的方法
        b.test();
    }
}

/*
package com.oop.demo05;

public class A extends  B{

    //Override 重写
    @Override//注解：有功能的注释！
    public void test() {
        System.out.println("A=>test()");
    }
}
 */

/*
package com.oop.demo05;

public class B {
    public void test(){
        System.out.println("B=>test()");
    }
}
 */

重写：需要有继承关系，子类重写父类的方法！

  1. 方法名必须相同
  2. 参数列表必须相同
  3. 修饰符：范围可以扩大但不能缩小：public>Protected>Default>private
  4. 抛出的异常：范围，可以被缩小，但不能扩大；ClassNotFoundException --> Exception(大)

重写，子类的方法和父类必须一致；方法体不同！

为什么需要重写:

  1. 父类的功能，子类不一定需要，或者不一定满足！

Alt+Insert : override;

多态

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
package com.oop;

import com.oop.demo06.Person;
import com.oop.demo06.Student;

public class Application {
    public static void main(String[] args) {
        //一个对象的实际类型是确定的
        //new Student();
        //new Person();

        //可以指向的引用类型就不确定了:父类的引用指向子类

        //Student 能调用的方法都是自己的或者继承父类的！
        Student s1 = new Student();
        //Person 父类型，可以指向子类，但是不能调用子类独有的方法
        Person s2 = new Student();
        Object s3 = new Student();

        //对象能执行哪些方法，主要看对象左边的类型，和右边关系不大！
        s2.run();//子类重写了父类的方法，执行子类的方法
        s1.run();
    }
}

/*
package com.oop.demo06;

public class Person {
    public void run(){
        System.out.println("run");
    }
}
 */

/*
package com.oop.demo06;

public class Student extends Person{
    @Override
    public void run() {
        System.out.println("son");
    }
    public void eat(){
        System.out.println("eat");
    }
}
 */

多态注意事项：

  1. 多态是方法的多态，属性没有多态
  2. 父类和子类，有联系 类型转换异常！ClassCastException!
  3. 存在条件： 继承关系，方法需要重写，父类引用指向子类对象！ Father f1 = new Son();

以下不能重写：

  • static 方法，属于类，它不属于实例
  • final 常量
  • private 方法；

instanceof

判断一个对象是什么类型

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
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
package com.oop;

import com.oop.demo06.Person;
import com.oop.demo06.Student;
import com.oop.demo06.Teacher;

public class Application {
    public static void main(String[] args) {

        //Object > String
        //Object > Person > Teacher
        //Object > Person > Student
        Object object = new Student();

        //System.out.println(X instanceof Y);能不能编译通过，看X与Y之间有无父子关系

        System.out.println(object instanceof Student);//true
        System.out.println(object instanceof Person);//true
        System.out.println(object instanceof Object);//true
        System.out.println(object instanceof Teacher);//False
        System.out.println(object instanceof String);//False
        System.out.println("====================================");
        Person person = new Student();
        System.out.println(person instanceof Student);//true
        System.out.println(person instanceof Person);//true
        System.out.println(person instanceof Object);//true
        System.out.println(person instanceof Teacher);//False
        //System.out.println(person instanceof String);//编译报错
        System.out.println("====================================");
        Student student = new Student();
        System.out.println(student instanceof Student);//true
        System.out.println(student instanceof Person);//true
        System.out.println(student instanceof Object);//true
        //System.out.println(student instanceof Teacher);//编译报错
        //System.out.println(student instanceof String);//编译报错
    }
}

/*
package com.oop.demo06;

public class Person {
    public void run(){
        System.out.println("run");
    }
}
 */

/*
package com.oop.demo06;

public class Teacher extends Person{
}
 */

/*
package com.oop.demo06;

public class Student extends Person{
    public void go(){
        System.out.println("go");
    }
}
 */

类型之间的转换：

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
package com.oop;

import com.oop.demo06.Person;
import com.oop.demo06.Student;
import com.oop.demo06.Teacher;

public class Application {
    public static void main(String[] args) {
        //类型之间的转换：父  子

        //高                     低
        Person obj = new Student();

        //student将这个对象转换为Student类型，我们就可以使用Student类型的方法了！
        Student student = (Student) obj;
        student.go();
        
        //子类转换为父类，可能丢失自己的本来的一些方法！
        Student stu = new Student();
        stu.go();
        Person person = stu;
    }
}

/*
package com.oop.demo06;

public class Person {
    public void run(){
        System.out.println("run");
    }
}
 */

/*
package com.oop.demo06;

public class Student extends Person{
    public void go(){
        System.out.println("go");
    }
}
 */

多态小结

  1. 父类引用指向子类的对象
  2. 把子类转换为父类，向上转型；
  3. 把父类转换为子类，向下转型；强制转换
  4. 方便方法的调用，减少重复的代码！简洁

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
package com.oop.demo07;

//static
public class Student {
    private static int age;//静态的变量
    private double score;//非静态的变量

    public void run(){
        go();
    }

    public static void go(){
        //run();
    }

    public static void main(String[] args) {
        Student s1 = new Student();

        System.out.println(Student.age);
        //System.out.println(Student.score);
        System.out.println(s1.age);
        System.out.println(s1.score);

        //run();
        go();
    }
}

先执行静态代码块（只执行一次），再执行匿名代码块，最后执行构造方法

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
package com.oop.demo07;

public class Person {
    //2： 赋初值
    {
        System.out.println("匿名代码块");
    }
    //1： 只执行一次
    static {
        System.out.println("静态代码块");
    }
    //3
    public Person() {
        System.out.println("构造方法");
    }

    public static void main(String[] args) {
        Person person1 = new Person();
        System.out.println("=================");
        Person person2 = new Person();
    }
}

静态导入包

1
2
3
4
5
6
7
8
9
10
11
12
package com.oop.demo07;

//静态导入包
import static java.lang.Math.random;
import static java.lang.Math.PI;

public class Test {
    public static void main(String[] args) {
        System.out.println(random());
        System.out.println(PI);
    }
}

如果一个类被final定义，则这个类不能被继承

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
50
51
52
package com.oop.demo07;

//static
public class Student extends Person{  //会爆红
    private static int age;//静态的变量
    private double score;//非静态的变量

    public void run(){
        go();
    }

    public static void go(){
        //run();
    }

    public static void main(String[] args) {
        Student s1 = new Student();

        System.out.println(Student.age);
        //System.out.println(Student.score);
        System.out.println(s1.age);
        System.out.println(s1.score);

        //run();
        go();
    }
}

/*
package com.oop.demo07;

public final class Person {
    //2： 赋初值
    {
        System.out.println("匿名代码块");
    }
    //1： 只执行一次
    static {
        System.out.println("静态代码块");
    }
    //3
    public Person() {
        System.out.println("构造方法");
    }

    public static void main(String[] args) {
        Person person1 = new Person();
        System.out.println("=================");
        Person person2 = new Person();
    }
}
 */

抽象类

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
package com.oop.demo08;

//继承了抽象类的子类，必须实现该抽象类的所有方法
public class A extends Action{
    @Override
    public void doSomething() {
        super.doSomething();
    }
}
/*
package com.oop.demo08;

//abstract 抽象类
public abstract class Action {
    //约束~有人帮我们实现~
    //abstract,抽象方法，只有方法名字，没有方法的实现！
    public void doSomething(){

    }
}
 */

Java的类是单继承，但是接口可以多继承

抽象类的特点：

  1. 不能new这个抽象类，只能靠子类去实现它：约束！
  2. 抽象类中可以写普通的方法
  3. 抽象方法必须在抽象类中

思考题？

  1. 抽象类中存在构造器吗？

    抽象类可以有构造方法，只是不能直接创建抽象类的实例对象而已。在继承了抽象类的子类中通过super()或super(参数列表)调用抽象类中的构造方法。示例代码如下：

    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
    package ahu;
     
    abstract class Base{
        int a=7;
        public Base(){
        	a=8;
        }
        public Base(int i){
        	a=i;
        }
    }
    public class Demo01 extends Base {
    	public Demo01(){
    		super();
    	}
    	public Demo01(int i){
    		super(i);
    	}
    	public static void main(String[] args) {
    		Demo01 demo=new Demo01();
    	    System.out.println(demo.a);//8
    	    Demo01 demo1=new Demo01(9);
    	    System.out.println(demo1.a);//9
    	}
    }

  2. 抽象类存在的意义？

    抽象的意义:对代码的维护和重用。

    抽象类往往用来表征对问题领域进行分析、设计中得出的抽象概念，是对一系列看上去不同，但是本质上相同的具体概念的抽象。具体分析如下：

    1.因为抽象类不能实例化对象，所以必须要有子类来实现它之后才能使用。这样就可以把一些具有相同属性和方法的组件进行抽象，这样更有利于代码和程序的维护。

    比如本科和研究生可以抽象成学生，他们有相同的属性和方法。这样当你对其中某个类进行修改时会受到父类的限制，这样就会提醒开发人员有些东西不能进行随意修改，这样可以对比较重要的东西进行统一的限制，也算是一种保护，对维护会有很大的帮助。
    2.当又有一个具有相似的组件产生时，只需要实现该抽象类就可以获得该抽象类的那些属性和方法。
    比如学校又新产生了专科生这类学生，那么专科生直接继承学生，然后对自己特有的属性和方法进行补充即可。这样对于代码的重用也是很好的体现。

    所以，Java中抽象类对于代码的维护和重用有很好的帮助，也是Java面向对象的一个重要体现。

接口

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
50
51
52
53
54
55
56
57
58
package com.oop.demo09;

//抽象类： extends
//类 可以实现接口 implements 接口
//实现了接口的类，就需要重写接口中的方法

//多继承~利用接口实现多继承
public class UserServiceImpl implements UserService,TimeService{
    @Override
    public void add(String name) {
        
    }

    @Override
    public void delete(String name) {

    }

    @Override
    public void update(String name) {

    }

    @Override
    public void query(String name) {

    }

    @Override
    public void timer() {
        
    }
}

/*
package com.oop.demo09;

//interface 定义的关键字，接口都需要有实现类
public interface UserService {
    
    //常量~public static final
    int AGE = 99;
    
    //接口中的所有定义的方法其实都是抽象的 public abstract
    void add (String name);
    void delete (String name);
    void update (String name);
    void query (String name);
}
 */

/*
package com.oop.demo09;

public interface TimeService {
    void timer();
}
 */

接口的作用：

  1. 约束
  2. 定义一些方法，让不同的人实现
  3. public abstract
  4. public static final
  5. 接口不能被实例化，接口中没有构造方法
  6. implements可以实现多个接口
  7. 必须要重写接口中的方法

内部类

image-20220404164103118

成员内部类

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
package com.oop;

import com.oop.demo10.Outer;

public class Application {
    public static void main(String[] args) {
        //new
        Outer outer = new Outer();
        //通过这个外部类来实例内部类
        Outer.Inner inner = outer.new Inner();
        inner.in();
        inner.getID();
    }
}

/*
package com.oop.demo10;

public class Outer {
    public int id;
    public void out(){
        System.out.println("这是外部类的方法");
    }
    public class Inner{
        public void in(){
            System.out.println("这是内部类的方法");
        }

        //获得外部类的私有属性
        public void getID(){
            System.out.println(id);
        }
    }
}
 */

静态内部类

1
2
3
4
5
6
7
8
9
10
11
12
package com.oop.demo10;

public class Outer {

}

//一个java类中可以有多个class类，但是只能有一个public class类
class A{
    public static void main(String[] args) {
        
    }
}

局部内部类

1
2
3
4
5
6
7
8
9
10
11
package com.oop.demo10;

public class Outer {
    public void method(){
        class Inner{
            public void in(){
                
            }
        }
    }
}

匿名内部类

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
package com.oop.demo10;

public class Test {
    public static void main(String[] args) {
        //没有名字初始化类,不用将实例保存到变量中
        new Apple.eat();
        
        new UserService() {
            @Override
            public void hello() {

            }
        };
    }
}

class Apple{
    public void eat(){
        System.out.println("1");
    }
}

interface UserService{
    void hello();
}