面向对象编程（高级）笔记

最新推荐文章于 2024-06-23 18:22:51 发布
最新推荐文章于 2024-06-23 18:22:51 发布
阅读量1.5k 收藏 36
点赞数 42
文章标签： 笔记
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/hawk_of_IT/article/details/135159914
版权

static

类变量：也就是静态变量，是所有该类的对象共享的，static变量在类加载的时候就生成了，可通过对象名访问，也可通过类名直接访问，要遵守修饰符规则。

1. 类变量也叫静态变量/静态属性，是该类的所有对象共享的变量。任何一个该类的对象去访问它，取到的都是相同的值，同样，任何一个对象去修改它，修改的也是同一个变量。

2. 定义语法（常用）： 访问修饰符  static  数据类型 变量名；

3. 访问类变量： 类名.类变量名[推荐以这种形式访问]

                           对象名.类变量名

4. 类变量在类加载时就初始化了，也就是说，即使没有创建对象，只要类加载了，类变量就可以使用了。

5. 只要类还存在，类变量就存在，与对象无关。

类方法：也叫静态方法。

public static 数据返回类型 方法名（）{}

类方法的调用与类变量相似。推荐使用类名直接访问。

类名.类方法名

1. 类方法不允许使用和对象有关的关键字（this、super）

2. 类方法中只能访问静态变量或静态方法。（普通成员方法既可以访问静态的也可以访问非静态的）

main

另外，在main()方法中，可以访问main方法所在类的静态属性静态方法，但是不能访问该类的非静态方法，必须实例化一个该类的对象去访问。 

代码块 

基本语法：

[修饰符] {

        代码;

}；// (;)可省略

注意： 修饰符只能是static。带static的是静态代码块，不带的是普通代码块

使用细节：

1. static代码块作用是对类的初始化，随着类的加载而执行，并且只执行一次。普通代码块，每创建一个对象，就执行一次。（使用类的静态成员时，普通代码块不会被调用。）

2. 类在什么时候加载：【重点】

        1）创建对象实例时（new）

        2）创建子类对象实例，父类也会被加载

        3）使用类的静态成员时（静态属性、静态方法）

3. 创建一个对象时，在一个类中调用顺序：

        1） （在创建对象时，先加载了类）调用静态代码块和静态属性初始化，它俩优先级相同，取决于定义顺序

        2） 调用普通代码块和普通属性初始化，它俩优先级相同，取决于定义顺序

        3） 调用构造方法

4. 构造器的最前面其实隐藏了super()和 调用普通代码块，静态相关的代码块和属性，在类加载时就执行完毕，因此，是优先于构造器和普通代码块执行的

class AA{
    public AA(){//构造器
        //这有隐藏的执行要求
        //(1) super()
        //(2) 调用代码块
        println("输出");
    }
}

 5. 创建一个子类时的调用顺序，看下图

final

final关键字用于表示常量。它可以与变量，方法和类一起使用。

任何实体（变量，方法或类）一旦被声明final后，只能分配一次。也就是，

  • final变量不能用另一个值重新初始化

  • final方法不能被重写

  • final类不能被继承

1. final修饰的属性又叫常量，用XX_XX_XX来命名。

2. final修饰的属性必须赋初值，且不能再修改，可再以下位置赋值：

        1） 定义时，如 private final double TAX_RATE = 0.21;

        2）在构造器中

        3） 代码块中，

3. 如果final修饰的是static属性时，只能在定义时or静态代码块中赋值。

4. final类不能被继承，可以实例化对象

5. final方法不能被重写，但可以被继承。

6. final不能修饰构造方法

7. ★final往往搭配static使用，效率更高，它不会导致类加载，底层编译器做了优化处理。

public class Test {
    public static void main(String[] args) {
        System.out.println(AA.num);
    }
}
class AA{
    public final static int num = 100;
    public static void method(){
        System.out.println("调用了静态方法");
    }
}

测试可知，只是输出了num，并没有输出方法里的语句，说明类并没有加载。

abstract

抽象类不能被实例化对象。         abstract只能修饰类和方法。

抽象类可以没有抽象方法。但有抽象方法的类必须是抽象类。

抽象类可以有任何成员，抽象类也是类。

抽象方法不能有主体（即不能加 { } ）。

如果一个类继承了抽象类，那它比须实现抽象类的所有抽象方法，除非他自己也是抽象类。

抽象方法不能再用private\final\static修饰了，因为他们的作用是相反的。（前者需要继承，后者不需要继承）

接口

接口（interface）: 接口就是将一些没有实现的方法封装到一起，到某个类要使用的时候，再根据具体情况将这些方法写出来

语法：

interface 接口名{
    //属性
    //方法
}

当别的类需要接入接口时，

class AA implements 接口名{
    自己属性；
    自己方法；
    必须实现接口中的抽象方法；
}

注意： jdk7.0前接口中的方法没有方法体。jdk8.0后接口中的方法可以有静态方法、默认方法。

interface Usb{
    void work(); //抽象方法
    default public void test(){
        //默认方法
    }
    public static void test2(){
        //静态方法
    }
}

细节：

1. 接口不能被实例化

2. 接口中所有方法都是public方法，接口中的抽象方法可以省略掉“abstract”

3. 普通接口要想接入接口，必须实现接口中的所有抽象方法。抽象类不需要。

4. 一个类可以实现多个接口： class AA implement 接口1, 接口2{ }

5. 接口中的属性都是final的，而且是 public static final  比如：

        int a = 1; 实际上是 public static final int a = 1;

        访问形式： 接口名.属性名

6. 接口不能继承其他类，但可以继承多个其他接口，多个。

        interface AA extends BB, CC; // AA BB CC 都是接口名

7. 接口的修饰符只能是public和默认，和类一样。

接口vs继承

继承的话，子类自动拥有父类的技能。如果子类想扩展技能的话，可以通过接口来实现。

可以理解 接口 是对 继承 的一种补充。

接口的作用：设计，设计好各种规范（方法），让其他类去实现

继承的作用：解决代码的复用性和可维护性。

接口比继承更灵活。

接口同继承一样，有多态特性：

可以向上转。向下转。有多态数组

另外，接口存在多态传递现象：

内部类

众所周知，类有五大成员，分别是，属性、方法、构造器、代码块，还有本节的主角--内部类。

内部类又根据定义位置不同分为：

                定义在外部类的局部位置上（方法、代码块中）：

                                1. 局部内部类（有类名） 2. 匿名内部类（无类名）

                定义在外部类的成员位置上：

                                1. 成员内部类 2. 静态内部类

其中，匿名内部类较常用，也就是很重要！！！

局部内部类

/**
 * 局部内部类
 */
public class LocalInnerClass {
    public static void main(String[] args) {
        Outer01 outer01_xx = new Outer01();
        outer01_xx.method();

    }
}
class Outer01{
    private int n1 = 20;
    public void method(){
        //1. 局部内部类定义在类的局部位置，通常是方法或代码块中
        //2. 局部内部类不能用访问修饰符，除了final
        //3. 局部内部类本质上还是一个类（可以有类该有的东西）
        //5. 作用域：仅仅在定义他的方法或代码块
        class innerClass{//有类名
            //4. 局部内部类可以直接访问外部类的成员
            private int n1 = 80;
            public void innerMethod(){
                // 如果外部类和内部类的成员重名，遵循就近访问原则。
                // 如果想访问外部类成员，可以使用（外部类名.this.成员）去访问
                //因为Outer01.this本质上就是外部类的对象,相当于outer01_xx(在main中)，
                // 可用hashcode值来验证
                System.out.println("n1 = " + n1 + "\n外部类的成员n1 = " + Outer01.this.n1);
                f1();
            }
        }
        //外部类可以通过创建内部类对象来访问内部类
        innerClass innerClass = new innerClass();
        innerClass.innerMethod();

    }


    private void f1(){
        System.out.println("外部方法");

    }
    private void f2(){
        //new innerClass()
        //外部其他类不能访问局部内部类，因为局部内部类是个局部变量；
    }
}

匿名内部类

/**
 * 匿名内部类
 */
public class AnonymousInnerClass {
    public static void main(String[] args) {
        Outer03 outer03 = new Outer03();
        outer03.method();

    }
}

class Outer03{//外部类
    public void method(){//方法
        //一、基于接口的匿名内部类
        //假设现在需要使用接口，传统方法是写一个类，实现该接口，并创建对象
        //Tiger tiger = new Tiger(); 或者：
        IA tiger = new Tiger();
        tiger.cry();
        //但是需求是Tiger/Dog只使用一次，后面不再使用
        //因此可以使用匿名内部类来简化开发
        // cat 编译类型 IA，
        // cat 运行类型 是匿名内部类 (底层分配类名 xxx ---> Outer03$1)
        /*
            底层：
            class xxx implements IA{
                public void cry() {
                    System.out.println("小猫喵喵叫~~~");
                }
            }

         */
        //jdk底层在创建匿名内部类时，就立即创建了Outer03$1实例，并把地址返回给了cat
        //匿名内部类使用一次，就不能在使用了。
        //  因为（个人理解）只在创建匿名内部类时创建了实例，之后就不能再创建了
        //但是这个对象cat是一直存在的，可以一直使用。
        IA cat = new IA() {
            public void cry() {
                System.out.println("小猫喵喵叫~~~");
            }
        };
        cat.cry();

        //二、基于类的匿名内部类
        //Father father = new Father("jack");  这样不加括号就是正常的创建了一个对象
        /*
            底层：
            class Outer03$2 extends Father{
                @Override
                public void test() {
                    System.out.println("重写了test方法");
                }
            }
            // 同时也返回了 匿名内部类Outer03$2的对象 给了father
         */
        Father father = new Father("jack"){//匿名内部类，加括号

            //可以重写test的方法
            @Override
            public void test() {
                System.out.println("重写了test方法");
            }
        };

        // 三、 基于抽象类的匿名内部类（必须实现抽象方法）
        new Animals(){
            void cry(){
                System.out.println("小猪 哼哼叫~~~");
            }
        };

    }

}
interface IA{//接口
    public void cry();
}
class Tiger implements IA{
    @Override
    public void cry() {
        System.out.println("老虎嗷嗷叫~~~");
    }
}
class Dog implements IA{
    @Override
    public void cry() {
        System.out.println("小狗汪汪叫~~~");
    }
}

class Father{
    String name;

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

    }
}

abstract class Animals{
    abstract void cry();
}

注意匿名内部类底层的实现，以及它的运行类型是什么。

匿名内部类 可直接访问外部类成员，包括私有的。匿名内部类不能加访问修饰符。作用域仅在定义它的方法或代码块中。

外部类不能访问匿名内部类

匿名内部类有几种使用方法如下：

class Outer04{//外部类

    public void Method(){
        //匿名内部类的使用一
        Person p = new Person("Tom"){
            @Override
            public void introduce() {
                super.introduce();
            }
        };
        p.introduce();
        //匿名内部类的使用二
        new Person("Jerry"){
            public void hi(){
                System.out.println("hi my name is Jerry");
            }
        }.hi();
    }

}

class Person{
    private String name;

    public Person(String name) {
        this.name = name;
    }
    public void introduce(){
        System.out.println("我的名字是：" + name);
    }
}

成员内部类

静态内部类

hawk_of_IT
关注
  • 42
    点赞
  • 踩
  • 36
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
C++面向对象高级编程笔记
04-13
C++面向对象高级编程笔记
PHP 高级课程笔记 面向对象
10-29
类是面向对象编程的基础，它是一个模板或者蓝图，用于创建具有相同属性和行为的对象。在PHP中，我们可以使用`class`关键字来定义一个类。例如： ```php class User { // 属性 public $name; // 构造函数 ...
WEB前端JavaScript高级—面向对象编程
魏德曼的博客
11-30 119
WEB前端JavaScript高级—面向对象编程
20前端学习之js高级:面向对象、案例:面向对象的tab栏
浅弋、璃鱼的博客
08-01 551
文章目录一、什么是面向对象:1. 两大编程思想:2. 面向过程编程(POP)3. 面向对象编程(OOP):二、ES6中的类和对象：1. 面向对象的思维特点:2. 对象:3. 类: class4. 创建类:4.1 语法:4.2 类constructor 构造方法:4.3 类中添加方法:4.4 类的继承:4.5 super:5. ES6中类和对象: 一、什么是面向对象: 1. 两大编程思想: 面向过程: 面向对象: 2. 面向过程编程(POP) 面向过程就是分析出解决问题所需要的步骤, 然后用函数把这些步骤
2024年Web前端最全JavaScript 高级——详谈面向对象，2024年最新web界面研发工程师
2401_84435768的博客
05-11 563
一个好的心态和一个坚持的心很重要，很多冲着高薪的人想学习前端，但是能学到最后的没有几个，遇到困难就放弃了，这种人到处都是，就是因为有的东西难，所以他的回报才很大，我们评判一个前端开发者是什么水平，就是他解决问题的能力有多强。开源分享：【大厂前端面试题解析+核心总结学习笔记+真实项目实战+最新讲解视频】分享一些前端面试题以及学习路线给大家/*类中的成员：属性和方法*/// 构造函数在根据类创建对象的时候自动调用执行count++console.log(‘构造函数执行了’+count+‘次’)
javascript json_JavaScript学习3
weixin_39620684的博客
11-21 75
JSON是JavaScript Object Notation的缩写，它是一种数据交换格式。在JSON出现之前，大家一直用XML来传递数据。因为XML是一种纯文本格式，所以它适合在网络上交换数据。XML本身不算复杂，但是，加上DTD、XSD、XPath、XSLT等一大堆复杂的规范以后，任何正常的软件开发人员碰到XML都会感觉头大了，最后大家发现，即使你努力钻研几个月，也未必搞得清楚XML的规范。终...
高级Js-面向对象编程
失心疯的博客
08-23 1481
高级Js-面向对象编程 目录 JavaScript Window-浏览器对象模型 匿名包装器 工厂方式 同一个引用 构造函数与new命令 JavaScript Window-浏览器对象模型 浏览器对象模型(BOM) 所有浏览器都支持 window 对象. 它表示浏览器窗口. 全局变量是 window 对象的属性. 全局函数是 window 对象的方法. 甚至 HTML ...
前端知识汇总【JS之面向对象高级、线程机制与事件机制】
qq_44810886的博客
06-26 277
面向对象高级、线程与进程、事件循环等学习笔记
Python随手笔记(九)——–面向对象高级编程（1）
12-22
9.1 使用_slots_ 正常情况下，当我们定义了一个class，创建了一个class的实例后，我们可以给该实例绑定任何属性和方法，这就是动态语言的灵活性。先定义class： >>> class Animal(object): pass ...
Python随手笔记(九)——–面向对象高级编程（4）
12-22
定制类 看到类似__slots__这种形如__xxx__的变量或者函数名就要注意，这些在Python中是有特殊用途的。 __slots__我们已经知道怎么用了，len()方法我们也知道是为了能让class作用于len()函数。 Python的class中还有...
python学习笔记-面向对象高级编程-20200324
12-21
文章目录面向对象高级编程使用__slots__使用__slots__使用@property练习多重继承Mixln小结定制类__str____iter____getitem____getattr____call__小结使用枚举类exercise小结使用元类type（）metaclass 面向对象高级...
前端基础学习之js高级-面向对象-实现继承的几种方式
no pains,no gains
09-10 207
首先简单说一下构造函数、实例对象、原型对象之间的关系： 通过构造函数可以创建实例对象。 构造函数中有一个prototype属性，这个属性指向构造函数的原型对象。 通过构造函数创建的实例对象中有一个__proto__属性，这个属性指向这个实力对象对应的构造函数的原型对象。 构造函数的原型对象中有一个constructor构造器属性，这个属性指向这个原型对象所在的构造函数。 原型对象中的属性和方法可以被实例对象共享 原型对象的作用：实现数据共享，节省内存空间；实现继承，节省内存空间 构造函数的原型对象(pro
前端如何实现面向对象
杨晓风 迷迭香的记忆
07-09 311
前端如何实现面向对象：构造函数和原型链：使用构造函数创建对象，并通过原型链来共享方法和属性。可以使用new关键字实例化对象，并使用this关键字在构造函数中定义属性和方法。然后，通过将方法和属性添加到构造函数的原型上，可以实现方法和属性的共享。类和继承：使用ES6引入的类和继承语法来实现面向对象编程。可以使用class关键字定义类，并使用extends关键字实现继承。类中可以定义属性和方法，并使用方法初始化对象。原型对象：使用原型对象创建对象，并通过原型链来共享方法和属性。可以使用。
前端深入理解JavaScript面向对象编程与Class
欢迎来到我的前端博客！这里汇集了关于前端开发的最新技术、实用工具和经验分享。我将为你提供详细的教程、代码示例和实战案例，帮助你掌握Web开发的核心概念和技能。不论你是初学者还是有经验的开发者，这个博客都适合你。
09-14 1722
面向对象编程（Object-Oriented Programming，简称OOP）是一种编程范式，它将程序中的对象作为基本单元，通过封装、继承和多态等机制来组织和管理代码。面向对象编程将现实世界中的实体抽象为代码中的对象，对象拥有自己的状态（属性）和行为（方法），并与其他对象进行交互。封装（Encapsulation）：将数据和操作数据的方法封装在一个对象中，使其成为一个独立的实体，外部无法直接访问对象的内部实现细节。继承（Inheritance）
JS高级之面向对象篇（包含this判定规则、深 / 浅拷贝、原型/原型链等的详解）
ailsa_csdn的博客
03-06 582
慕课网前端工程师之面向对象的学习
前端中的面向对象（通俗向）
热门推荐
水稻南曦jsnancy的博客
05-17 1万+
话不多说。面向对象，面向过程， 面向数据本篇主要说 前端中的面向对象。一、对象：一切事物皆对象     电视、收音机、手机eg: var new Date(); arr；总结：不了解原理的情况下，就能使用其功能。   面向对象          不了解内部原理的结构，知道表面的各种操作（电视机按钮）。   对象          你只管用,不用操心内部的具体实现          对象：万物...
JAVA基础（JAVA SE）学习笔记（八）面向对象编程（高级）
时时师师的博客
10-24 243
关键字static、final、abstract的使用；main的理解；接口、内部类、枚举、注解；String与基本数据类型、包装类的转换。
git 初基本使用-----------笔记(结合idea)
最新发布
qq_48050838的博客
06-23 935
而 "update project" 是 IntelliJ IDEA 的功能，用于更新项目并将远程仓库最新更改应用到你的项目中。每次提交都会创建一个新的版本，并保存一个指向该版本的引用（通常称为提交哈希或提交 ID）。如果你是github、gitlab,你就选Repository URL，这里也会输入账号密码，或者token什么的，视情况输入即可。当你想要在本地开始一个新的项目，或者获取一个已有项目的副本时，你可以使用。在这个例子中，提交信息为。作为这次提交的描述，意味着这次提交是初始化仓库的提交。
python核心笔记-51页
06-01
13. 面向对象编程：讲解类、对象、继承和多态，展现Python的面向对象特性。 14. 执行环境：讨论Python的运行时环境，如解释器和虚拟机。 第二部分是高级主题，包括： 1. 正则表达式：教授如何使用正则表达式进行...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值