程序员最喜欢的一句话？当然是New对象啦~ Java随笔

发表于

「这是我参与11月更文挑战的第13天，活动详情查看：2021最后一次更文挑战」

相关文章

Java随笔记：Java随笔记

  • 兄弟萌，我真撑不住了，最近忙的要死，实在没时间写啊！！！！这万年老存稿（水文）都被逼得发出来了！啊！
    1、面向对象概念：
    举例：大象装进冰箱。
    面向过程：强调的是过程（动作）。
    打开冰箱
    存储大象
    关上冰箱
1
2
3
4
markdown复制代码  面向对象：强调的是对象（实体）。冰箱自带打开、存储、关闭等功能。
      冰箱打开
      冰箱存储
      冰箱关闭

特点：
面向对象就是一种常见的思想，符合人们的思考习惯。
面向对象的出现，将复杂的问题简单化。
面向对象的出现，让曾经在过程中的执行者，变成了对象中的指挥者。

2、类与对象的关系：
类是拥有相同行为特征对象的一个抽象概念。事物的描述。
对象是类这个抽象概念中事实存在的个体。该类事物的描述。
在java中对象通过new来创建的。

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
typescript复制代码范例：
    public class Car {
        private int num;//汽车轮子数量
        private String color;//汽车车身颜色

        public int getNum() {
            return num;
        }

        public String getColor() {
            return color;
        }

        public void setNum(int num) {
            this.num = num;
        }

        public void setColor(String color) {
            this.color = color;
        }

        @Override
        public String toString() {
            return "Car{" +
                    "num=" + num +
                    ", color='" + color + '\'' +
                    '}';
        }
    }

    主函数{
        Car car = new Car();//car就是一个类类型的引用变量，指向了该类的对象
    }
    
    匿名对象：当对象方法仅进行一次调用时，就可以简化成匿名对象。
        范例：
            new Car().getColor();

3、封装（三大特性之一）：
是指隐藏对象的属性和实现细节，仅对外提供公共访问方式。

1
2
3
4
5
6
7
8
9
10
11
12
markdown复制代码好处：
    将变化隔离。
    便于使用。
    提高重用性。
    提高安全性。
封装原则：
    将不需要对外提供的内容都隐藏起。
    把属性都隐藏，提供公共方法对其访问。

private:
    私有，是一个权限修饰符，用于修饰成员。
    私有的内容只在本类中有效。

4、构造函数：
特点：
1）函数名与类名相同。
2）不用定义返回值类型。
3）没有具体的返回值。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
markdown复制代码作用：
    给对象进行初始化。————构建创造对象时调用的函数。

注意：
    1）默认构造函数的特点。
        创建对象都必须要通过构造函数初始化。
        一个类中如果没有定义过构造函数，那么类中会有一个默认的空构造函数。如果定义了制定的构造函数，那么类中的默认构造函数就没有了。

    2）多个构造函数是以重载的形式存在的。

和一般函数区别：
    构造函数：对象创建时，就会调用与之对应的构造函数，对对象进行初始化。
    一般函数：对象创建后，需要函数功能时才调用。

    构造函数：对象创建时，会调用只调用一次。
    一般函数：对象创建后，可调用多次。

什么时候定义构造函数呢？
    在描述事物时，该事物已存在就具备的一些内容，这些内容都定义在构造函数中。

5、this关键字：
特点：
this关键字代表其所在函数所属对象的引用。即：本类对象的引用。
也就是，哪个对象调用了this所在的函数，this就代表哪个对象。

1
2
3
4
5
6
7
8
9
10
11
12
kotlin复制代码什么时候使用this关键字呢？
    当在函数类需要调用该函数的对象时。
    当局部变量和成员变量重名，可以用关键字this来区分。

this调用构造函数时注意：
    只能定义在构造函数的第一行，因为初始化动作要先执行。

基本应用：
    判断是否为同龄人：
        public boolean compare(Person p){
            return this.age == p.age;
        }

6、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
30
31
32
33
34
35
36
markdown复制代码被修饰后的成员具有以下特点：
    1）随着类的加载而加载。
    2）优先于对象存在。
    3）被所有对象共享。
    4）可以直接被类名调用。

使用注意：
    1）静态方法只能访问静态成员。
    2）静态方法中不可以写this、super关键字。
    3）主函数是静态的。

成员变量和静态变量的区别？
    1） 两个变量的生命周期不一样：
        成员变量随着对象的创建而存在，随着对象的被回收而释放。
        静态变量随着类的加载而存在，随着类的消失而消失。
    2） 调用方式不同：
        成员变量只能被对象调用。
        静态变量可以被对象调用，还可以被类名调用。
    3）  别名不同：
        成员变量也被成为实例变量。
        静态变量被成为类变量。
    4） 数据存储位置不同：
        成员变量数据存储在堆内存的对象中，所以也叫对象的特有数据。
        静态变量数据存储在方法区中。（方法区中的静态区）

静态代码块：
    随着类的加载而加载，而且只执行一次。

    作用：
        用于给类进行初始化。因为有的类不需要对象，可直接调用静态代码块。


静态方法和构造方法的区别？
    静态方法：随着类的加载而加载，而且只执行一次。
    构造方法：是给对应的对象进行针对性的初始化。
    构造代码块：可以给所有对象进行初始化。

7、继承（三大特性之二）：
java中支持单继承，不直接支持多集成，但对c++中的多继承机制进行改良。
单继承：一个子类只能有一个直接父类。
多继承：一个子类可以有多个直接父类。————不直接支持，是因为当两个父类中有同名的方法时，就会有调用不确定性。
在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
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
scala复制代码java支持多层（多重继承）。
    c继承b，b继承a。就会出现继承体系，当要使用一个继承体系时：
        查看该体系中的顶层类，了解该体系的基本功能。
        创建体系中的最子类对象，完成功能的使用。


好处：
    提高了代码的复用性。
    让类与类之间产生了关系，给第三个特征多态提供了前提。

什么时候定义继承呢？
    当类与类之间存在所属关系的时候，就定义继承。xxx是yyy中的一种，xxx就可以继承yyy的一种。
    所属关系： is a 关系。

具体的体现：
    在子父类之中：
        1）成员变量。
            当本类中的成员和局部变量同名重名用this区分。
            当子父类中的成员变量同名用super区分为父类。

            this和super的区别：
                this代表本类对象的引用。
                super代表父类的空间。
            范例：
            calss fu{
                int num = 4;
            }

            class zi extends fu{
                int num = 5;
                void show(){
                    sout(this.num + "加" + super.num);
                }
            }
            主函数：{
                zi z = new zi();
                z.show();
            }
            打印：4加5

        2）成员函数。
            当子父类中出现成员函数一模一样的情况下：
                会运行子类的函数。这种现象被称为覆盖操作。
            函数的两个特性：
                1）重载：同一个类中。overload。
                2）覆盖（重写）：子类中，覆盖也成为重写（复写）。override。

                    重写注意事项：
                        1）子类方法重写父类方法时，子类权限必须要大于等于父类的权限。
                        2）静态只能重写静态，或被静态重写。
                    
                    什么时候使用重写操作？
                        当对一个类进行子类的扩展时，子类需要保留的功能声明，但需要定义子类中该功能的特有内容时，就使用重写操作完成。
                        
            范例：
            calss fu{
                void show(){
                    sout("old num");
                }
            }

            class zi extends fu{
                void show(){
                    sout("new pic");
                    sout("new img");
                    this.show();
                }
            }
            主函数：{
                zi z = new zi();
                z.show();
            }

        3）构造函数。
            在子类构造对象时，发现访问子类构造函数时，父类也运行了，原因是：在子类的构造函数中，第一行有一个隐式语句。super();————调用父类的构造函数。

            子类的实例化过程：子类中所有的构造函数默认都会访问父类中的空参数的构造函数。

8、final关键字
继承弊端：打破了封装性。用final禁止继承。
1）可以修饰类。方法、变量。
2）修饰的类不可以被继承。
3）修饰的方法不可以被重写。
4）修饰的变量是一个常量。只能在初始化时被赋值一次。
为什么要使用final修饰变量？
如果在程序中有一个数据是固定的，那么直接1使用这个数据就可以了，并且这个变量名称和值不能变化，加上final固定。
写法规范： 常量所有字母都大写，多个单词，中间用 _ 连接。
5）内部类只能访问被修饰的局部变量。

9、抽象类（基于继承）————abstract
抽象：笼统，模糊，不具体。

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
scala复制代码特点：
    1）方法只有声明没有实现时，该方法就是抽象方法，需要被abstract修饰，抽象方法必须定义在抽象类中。该类必须也被abstract修饰。
    2）抽象类不可以被实例化。为什么？因为调用抽象方法没有意义。
    3）抽象类必须由其子类重写了所有的抽象方法后，该子类才可以实例化，否则，这个子类还是抽象类。

范例：
 abstract calss 犬科{
     abstract void 吼叫();
 }

 class 狗 extends 犬科{
     sout("汪汪");
 }

 class 狼 extends 犬科{
     sout("嗷~~嗷~~");
 }

提出抽象类的五个问题：
    1）抽象类中有构造函数吗？
        有，用于给其子类进行初始化。

    2）抽象类可以不定义抽象方法吗？
        可以，但是很少见，目的就是不让该类创建对象。AWT的适配器对象就是这种类。通常这个类中有方法体，但是没有内容。
    
    3）抽象关键字不可以和哪些关键字共存？
        private 不行 ———— 因为抽象方法必须被重写。非法修饰符组合。
        static  不行 ———— 如果成员变静态，则不需要对象，抽象方法即无意义。
        final   不行 ———— 因为无法被重写。
    
    4）抽象类和一般类的异同点？
        异： 一般类有足够的信息描述事物。抽象类描述事物的信息可能不足。
            一般类中不能第一抽象方法，只能定义非抽象方法。抽象类中可以定义抽象方法，同时可以定义非抽象方法。
            一般类可以被实例化。抽象类不可以被实例化。
        同：都是用来描述事物的，都在内部定义了成员。
    
    5）抽象类一定是一个父类吗？
        一定是父类。
        因为某个类继承了抽象类，一定要重写其所有抽象方法才可以对其实例化，否则该类还是抽象类！

10、接口 interface
当一个抽象类中的方法都是抽象方法时，这时候可以将抽象类定义成接口。

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
csharp复制代码格式：
    interface {}

接口中的成员修饰符都是固定的：
    1）成员常量（全局变量）：public static final
    2）成员函数（抽象方法）：public abstract
    3）发现接口中的成员都是public的
由此得出结论：接口中的成员都是公共的权限。

接口不再使用继承，使用 implements 来实现接口。

范例：
    interface demo{
        public static final int num = 4;
        void show();
    }

    calss demoImpl implements demo{
        @Override
        public void show(){
            sout("我是一个接口中抽象方法的实现方法"); 
        }
    }

在java中不支持多继承，因为会出现调用的不确定性。
所以java将多继承机制进行了改良，在java中变成了多实现。
一个类可以实现多个接口。

范例：
    class Test implements 接口一,接口二{
        方法体;
    }

一个类在继承另一个类的同时，还可以实现多个接口。接口的出现避免了单继承的局限性。

细节：
    类与类之间是继承关系。
    类与接口之间是实现关系。
    接口与接口之间是继承关系。而且接口可以多继承。实现子接口时需重写子接口及所有父接口的所有抽象方法。

特点：
    1）接口是对外暴露的规则。
    2）接口是程序的功能拓展。
    3）接口的出现降低了耦合性。
    4）接口可以用来多实现。
    5）类与接口之间是实现关系，而且类可以继承一个类的同时实现多个接口。
    6）接口和接口之间可以有继承关系。

凡是对外暴露的东西都可以被称之为接口。


接口类与抽象类的异同点？
    
    同：都是不断向上抽取而来的。

    异： 1）抽象类需要被继承，而且只能单继承。接口需要被实现，而且可以多实现。
        2） 抽象类中可以定义抽象方法和非抽象方法，子类继承后，可以直接使用非抽象方法。
            接口中只能定义抽象方法，必须由子类区实现。
        3） 抽象类的继承是 is a 关系。在定义该体系基本共性内容。
            接口的实现是 like a 关系。在定义该体系额外功能。

11、多态
定义：某一种事物的多种存在形态。

1
2
3
4
5
6
7
8
9
10
11
12
ini复制代码例子：父类 名 = new 子类();
    动物中猫。狗。
    猫这个对象对应的类型就是猫类型。猫 x = new 猫();
    同时猫也是动物中的一种们也可以把猫称为动物。动物 y = new 猫();
    动物是猫和狗等具体事物中抽取出来的父类型，父类型引用指向了子类对象。

对象的多态性。
    猫这类事物即具有猫的形态，又具备着动物的形态。这就是对象的多态性。
    简单说就是一个对象对应着不同类型。

多态在代码中的体现：
    父类或者接口的引用指向其子类的对象。

路漫漫其修远兮，吾必将上下求索~

如果你认为i博主写的不错！写作不易，请点赞、关注、评论给博主一个鼓励吧~hahah

本文转载自: 掘金

开发者博客 – 和开发相关的 这里全都有

0%