Javase-OOP(高级)

最新推荐文章于 2022-05-26 11:45:00 发布
最新推荐文章于 2022-05-26 11:45:00 发布
阅读量261 收藏
点赞数
文章标签： java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Monica3567/article/details/121527431
版权

 1、类变量和类方法

1.1 什么是类变量

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

1.2 定义类变量

//访问修饰符 static 数据类型 变量名；
public static String name = "小明";

 1.3 如何访问静态变量

//类名.静态变量名【静态变量的访问你修饰符的访问权限和范围和普通属性是一样的】
//静态变量是随着类的加载创建，所以即使没有new对象也能访问
Car.name;

1.4 类变量的使用细节

1. 什么时候使用静态变量

        当我们需要让某个类的所有对象都共享一个变量时，就可以考虑使用静态变量。

2. 类变量与实例变量区别

        类变量是该类的所有对象共享的，而实例变量是每个对象独享的。

3. 加上static称为类变量或者静态变量，否则称为实例变量/普通变量/非静态变量

4. 静态变量可以通过 类名.类变量名 或者 对象名.类变量名  来访问，推荐使用 类名.类变量名方式访问。【前提是：  满足访问修饰符的访问权限和范围】

5. 实例变量不能通过 类名.方法名 来访问。

6. 类变量是在类加载的时候就创建了，所以我们没有创建对象实例。ps：不用new对象

7. 静态变量的生命周期是随着类的加载开始，随着类消亡而销毁。

1.5 定义类方法

//访问你修饰符 static 数据返回类型 方法名(){}

//1.放方法使用了static修饰后，该方法就是静态方法//2.静态方法就可以访问静态属性/变量
public static String getAge(){  

}

1.6 类方法经典的使用场景

1. 当方法中不涉及到任何和对象相关的成员，则可以将方法设计成静态方法，提高开发效率。

//比如：工具类中的方法 utils、Math类、Arrays类、Collections集合类的源码


//直接MyTools.calSum(a,b);就能调用//不用new对象
class MyTools{
    public static double calSum(int a,int b){
        return a + b;
    }
}

1.7 类方法使用细节

1. 类方法和普通方法都是随着类的加载而加载，将结构信息存储在方法区；类方法中无this的参数，普通方法中隐含着this的参数

2. 类方法可以通过类名调用，也可以通过对象名调用。

3. 普通方法和对象有关，需要通过对象名调用，比如 对象名.方法名(参数)，不能通过类名调用。

4. 类方法中不允许使用和对象有关的关键字，比如this和super。

5. 普通方法可以。静态方法只能访问静态变量或者静态方法。

6. 普通方法成员，既可以访问非静态成员，也可以访问静态成员。

结论：

  1. 静态方法只能访问静态成员

  2. 非静态方法，可以访问所有的成员

  3. 在编写代码时，仍要遵守访问权限规则

2、代码块 

2.1 基本介绍

代码化块又称为初始化块,属于类中的成员[即是类的一部分]， 类似于方法，将逻辑语句封装在方法体中，通过{}包围起来。

但和方法不同，没有方法名，没有返回值，没有参数，只有方法体，而且不用通过对象或类显式调用，而是加载类时，或创建对象时隐式调用。

2.2 基本语法 

//	[修饰符]{  代码  }；


static{
    
};

说明注意：

1. 修饰符可选，要写的话只能写static

2. 代码块分为两类，使用static修饰的叫静态代码块，没有static修饰的，叫做普通代码块/非静态代码块。

3. 逻辑语句可以为任何逻辑语句(输入、输出、方法调用、循环、判断等)

4. ；号可以写上，也可以省略

2.3 代码块的好处 

1. 相当于另外一种形式的构造器(对构造器的补充机制)，可以做初始化的操作

2. 场景：如果多个构造器种都有重复的语句，可以抽取到初始化代码块中，提高代码的复用性

class Movie{
    private String name;
    private double price;
    private String director;

    //这样不管当我们调用哪个构造器，都会先调用代码块种的内容
    //代码块的调用优先于构造器
    {
        System.out.println("电影屏幕打开。。。");
        System.out.println("广告开始。。。");
        System.out.println("电影开始。。。");
    }

    public Test(String name) {
        this.name = name;
    }

    public Test(String name, double price) {
        this.name = name;
        this.price = price;
    }

    public Test(String name, double price, String director) {
        this.name = name;
        this.price = price;
        this.director = director;
    }
}

 2.4 代码块使用注意事项和细节

        1. static代码块也叫静态代码块，作用就是对类进行初始化，而且它随着类的加载而执行，并*只会执行一次。如果是普通代码块，每创建一个对象，就执行。

        2. 类什么时候加载【重要！】

//1. 创建对象实例时(new)

class AA{
    static{
        System.out.println("AA 的静态代码块1被执行。。")
    }
}


AA aa = new AA();
//new对象就会执行静态代码块的内容
//输出    AA 的静态代码块1被执行。。
//2.创建子类对象实例，父类也会被加载
class BB extends AA{
    System.out.println("BB 的静态代码块1被执行。。")
}


BB bb = new BB();
//继承的本质：先加载父类在加载子类
//所以：AA 的静态代码块1被执行。。  先输出！
//	   BB 的静态代码块1被执行。。  后输出！
//3.使用类的静态成员时(静态属性，静态方法)


class Cat{
    public static int n1 = 999;//静态属性
    static{
        System.out.println("Cat 的静态代码块1被执行。。。")
    }
}


Cat.n1;//n1是静态属性，本类的静态成员被调用，所以静态代码块也会被调用
//所以输出：Cat 的静态代码块1被执行。。。
//		  999
//如果有Cat继承了父类，那么父类的静态代码块也会被加载，也比Cat先加载

        3. 普通代码块，在创建对象实例时，会被隐式的调用。被创建一次，就会被调用一次。

如果只是使用类的静态成员，普通代码块不会执行。

class AA{
    public static int a = 1;
    //静态代码块
    static{
        System.out.println("AA 的静态代码块1被执行。。");
    }
    //普通代码块
    {
       System.out.println("AA 的普通代码块1被执行。。"); 
    }
}

System.out.println(AA.a);
//这样调用只会执行静态代码块，不会执行普通代码块，因为没有new对象，
//普通代码块只会在创建对象实例化的时候才会被调用。而且时没创建一次就调用一次！
//在类加载的时候不会被调用！
//所以这里输出：AA 的静态代码块1被执行。。

        4. 总结

1. static代码块时类加载时执行的，类只加载一次，所以static代码块只执行一次

2. 普通代码块是在创建对象时调用的，创建一次，调用一次。

        5.  创建对象时，在一个类调用顺序是：(难点、重点)：


/**
*1. 调用静态代码块和静态属性初始化(注意：静态代码块和静态属性初始化调用的优先级一样，
*如果有多个静态代码块和多个静态变量初始化时，按照他们定义的顺序调用)
*
*
**/

class A{
    //静态属性初始化
    private static int n1 = getN1();
    //静态代码块
    static{
        System.out.println("A 静态代码块01");
    }
    public static int getN1(){
        Sysyem.out.println("getN1被调用");
        return 100;
    }
}


A a = new A();
//先输出 getN1()被调用
//在输出 A 静态代码块01
//原因：getN1先初始化，static后初始化。如果有多个静态成员按照他们定义的顺序调用。

/**
*2. 调用普通代码块和普通属性的初始化(注意：普通代码块和普通属性初始化调用的优先级一样，
*如果多个普通代码块和多个普通属性初始化，则按定义顺序调用)
**/

class A{
    //静态属性初始化
    private static int n1 = getN1();
    private int n2 = getN2();
    //静态代码块
    static{
        System.out.println("A 静态代码块01");
    }
    //普通代码块
    {
        System.out.println("A 普通码块02");
    }
    //静态方法
    public static int getN1(){
        Sysyem.out.println("静态方法getN1被调用");
        return 100;
    }
    
    //普通方法
    public  int getN2(){
        Sysyem.out.println("普通方法getN2被调用");
        return 200;
    }
    //无参构造器
    public void A(){
        Sysyem.out.println("无参构造器被调用了！");
}

A a = new A();
/*
输出顺序：1.静态方法getN1被调用
		2.A 静态代码块01
		3.普通方法getN2被调用
		4.A 普通码块02
		5.无参构造器被调用了
*/
//3. 调用构造器

创建对象时，一个类调用顺序是：

1. 调用静态代码块和静态属性初始化(注意：静态代码块和静态属性初始化调用的优先级一样，如果有多个静态代码块和多个静态变量初始化时，按照他们定义的顺序调用)

2. 调用普通代码块和普通属性的初始化(注意：普通代码块和普通属性初始化调用的优先级一样，如果多个普通代码块和多个普通属性初始化，则按定义顺序调用)

3. 调用构造方法

         6. 构造方法的最前面其实隐含了super()和调用普通代码块。

class A {
    //构造器
    public A(){
        //这里有隐藏得执行要求
        // 1.super();
        // 2.调用普通代码块
        System.out.println("it is ok");
    }
}

        7. 有继承关系的两个类：

public class Test {
    public static void main(String[] args) {
        /*
            1. 进行类的加载
                1.1 先加载父类 A 1.2 在加载 B
            2. 创建对象
                2.1 从子类的构造器开始
         */
        new B();
    }
}
class A {
    private static int n1 = getValue01();
    static {
        System.out.println("A的一个静态代码块");
    }
    {
        System.out.println("A的一个普通代码块");
    }
    public int n2 = getValue02();
    public static int getValue01(){
        System.out.println("getValue01");
        return 10;
    }
    public int getValue02(){
        System.out.println("getValue02");
        return 10;
    }

    public A(){
        System.out.println("A的构造器");
    }
}
class B extends A{
    private static int n3 = getValue03();
    static {
        System.out.println("B的一个静态方法");
    }
    {
        System.out.println("B的一个普通代码块");
    }
    public int n4 = getValue04();
    public static int getValue03(){
        System.out.println("getValue03");
        return 10;
    }
    public int getValue04(){
        System.out.println("getValue04");
        return 10;
    }
    public B(){
        //隐藏了super();
        //普通代码块
        //普通属性的初始化。。。
        System.out.println("B的构造器");
    }

}

/*
输出顺序：
	getValue01
A的一个静态代码块
getValue03
B的一个静态方法
A的一个普通代码块
getValue02
A的构造器
B的一个普通代码块
getValue04
B的构造器
*/

得出结论输出顺序：

1. 父类的静态代码块和静态方法（按照编写的顺序来）
2. 子类的静态代码块和静态方法（按照编写的顺序来）
3. 父类的普通代码块、普通方法（按照编写的顺序来）
4. 父类的构造方法
5. 子类的普通代码块、普通方法（按照编写的顺序来）
6. 子类的构造方法

        8.  静态代码块只能直接调用静态成员（静态属性和静态方法），普通代码块可以调用任意成员。

Monica3567
关注
JavaSE OOP
weixin_45495161的博客
07-06 82
若父类无没有无参构造器，子类继承的时候就需要用到super(参数)；来构建有参构造器，否则会报错，原因是Java默认会再子类构造器的第一行添加super()方法，因父类只有有参构造器所以super();没有起到作用，在子类就需要用super(参数)来构建子类只可以继承一个父类，Java实行的是单继承，多实现。例：Childern、Student均可以继承Person，但Student不能再继承Object。
JavaSE---Lambda&Stream语法
qq_44125413的博客
01-27 585
背景 有一个学生类，传入5个学生对象，然后用ArrayList存储并输出，传入时无序，想要输出时按照自然顺序（学生的学号大小）排序。Comparator是一个排序比较接口，里面定义了一个比较的方法，但是没有实现共4种方法 package com.ffyc.javaoop.day13.Lambda; public class Student { int no; String name; public Student(int no, String name) { th
JavaSE OOP(面向对象)学习入门
weixin_44717746的博客
06-09 166
OOP学习入门 面向对象学习的三大主线 一：java类及类的成员:属性、方法、构造器、代码块、内部类 二：面向对象的三大特征：封装、继承、多态 三：其他关键字：this、super、static、final、abstract、interface、package、import 以后会逐一总结，这次先总结第一个大块内容 1.类和对象： 对一个事务的描述，是抽象的，概念上的定义。即：具有相同属性和行为的对象的总称。 对象： 实际存在的该类的每个个体，因而也称为实例。万事万物皆对象（注：其实类也是对象，不过类是C
JavaSE-面向对象编程（oop）
授人以鱼
05-26 179
JavaSE-面向对象编程（oop）类与实例化对象构造器封装单继承重写多态instanceof 语法类型转换抽象类接口类（多继承）内部类成员内部类静态内部类局部内部类匿名内部类Object 类序列化、反序列化 面向对象编程的本质就是：以类的方式组织代码，以对象的方式组织（封装）数据。 面向对象的三大特性： 封装 继承 多态 类与实例化对象 实例化对象的方式 调用new语句创建对象 // Student.java public class Student{ String studentName;
JavaSE------面向对象（OOP）
墨迹
10-09 165
第五天总结 面向对象的思想 面向对象思想特点 1:可以将复杂的事情简单化 2:将我们从执行者变成了指挥者 角色发生了转换 面向对象特征 封装(encapsulation) 继承(inheritance) 多态(polymorphism). 类与对象及其应用 类：是一组相关的属性和行为的集合 对象：是该类事物的具体体现 定义类其实就是定义类的成员(成员变量和成员方法) 1:成员变量 和以前定义...
javase-思维导图.zip
08-04
总结起来，"javase-思维导图.zip"文件中的思维导图涵盖了Java SE编程的广泛主题，从基础语法到高级特性，为初学者提供了全面的学习路径。通过这个导图，学习者可以有条不紊地掌握Java SE的知识体系，逐步成长为熟练...
狂神说--javase06--面向对象编程
Mar.三月
04-20 318
1
新版java教程 全套javase零基础到高级视频教程小白自学编程下载地址
04-16
·讲解接口、继承、抽象等核心面向对象编程OOP思想 ,玩转java异常Exception体系和自定义异常 ,快速掌握常见数据结构和Collection集合框架体系基础 中级知识点 ,重点讲解Collection:集合框架体系List/Set/Map多种 ...
JavaSE程序设计课件：L02-Object-oriented programming - 2.pdf
05-28
在Java编程语言中，面向对象编程（Object-Oriented Programming，OOP）是一种核心概念，它强调通过对象来组织代码，模拟现实...在后续的学习中，还会涉及到继承、多态等更高级的面向对象概念，这些都是Java编程的基石。
Javase—OOP基本说明1
qq_39162424的博客
11-27 292
1.面向过程与面向对象的区别 1.面向过程：把解决问题的步骤先罗列出来，然后一步一步进行， 2.面向对象：把问题中的对象先找出来，然后建立它们之间的关系; 2.面向对象编程解决问题的步骤 1.找对象(一切具体的事物都是对象) 2.设置对象之间的关系 3.eclipse(IDE)开发工具(IBM) 1.安装，绿化版只需要解压，建议不用中文路径，路中无空格
JavaSE OOP 类的基本结构
lhf294的博客
08-09 462
JavaSE OOP 类的基本结构1. 面向对象的三大特征 <1> 封装：将数据和行为组合在一起，并对对象的使用者隐藏数据的实现方式，向外公开访问的接口。类中的方法就是一个很好的封装，外部只需要调用方法就能获取功能，外部不需要关系功能实现过程。 <2>继承：具有 （1）传递性：父类中的属性和方法子类也有，除了私有成员外、 （2）单根性：一个类只能继承一个父类） 概念：就是
JavaSE基础学习-OOP(面向对象程序设计)
挥剑决浮云，诸侯尽西来
05-24 225
初识Java Java是一门高级的面向对象的编程语言。 Java的设计者已经编写了Java的白皮书用来解释设计初衷，并且发布了一个简短摘要，主要包括以下11个方面。 简单性 面向对象 分布式 健壮性 安全性 体系结构中立 可移植性 解释性 高性能 多线程 动态性 以上11个方面这里就不一一解释了，有兴趣的可以去参考《JAVA核心技术》一书，这本书对学习JAVA还是很有帮助的。 (小脑洞:为什么Java这么流行？) Java通过JVM实现的"一处编写，到处执行"的特性。 JVM提供垃圾回收器，大多数情况
JavaSE学习笔记（四）——面向对象（OOP）
logan_520的博客
12-09 659
1.初识面向对象 面向过程与面向对象的关系——对于描述复杂的事务，为了从宏观上把握、从整体上合理分析，我们需要使用面向对象的的思维来分析整个系统。但是，具体到微观操作，仍然需要使用面向过程的思路去实现。 面向对象编程的本质：以类的方式组织代码，以对象的形式封装数据。 面向对象三大特征：封装、继承和多态 2.对象的创建分析 对象创建 类是抽象的、是对象的模板；而对象则是一个具体的事物。类实例化后会返回...
JavaSE-02(OOP、类与对象、内部类、枚举、接口)
Carson's Blog
09-12 853
一、类与对象（一）：成员变量、成员方法、构造器 1. 类与对象简介 1.1. 什么是类？ 类：是一类具有相同特性的事物的抽象描述，是一组相关属性和行为的集合。可以看成是一类事物的模板，使用事物的属性特征和行为特征来描述该类事物。 属性：就是该事物的状态信息。 行为：就是该事物能够做什么。 举例：小猫；属性：名字、体重、年龄、颜色；行为：走、跑、叫。 1.2. 什么是对象？ 对象：是一类事物的具体体现。对象是类的一个实例，必然具备该类事物的属性和行为。 举例：一只小猫 ；属性：tom、5kg、2岁、白色等；
Javase—OOP高级特性
qq_39162424的博客
11-27 274
1.包(package) 1.作用： 1.便于管理类 2.解决同名类的问题 2.如何使用包 1.包名一般使用小写字母，层次之间通过.运算符进行分隔；例如com.oracle.sanguosha 2.在类文件的第一行语句中使用 package com.oracle.sanguosha语句将类放在此包中 3.在一个类中使用其它包中的类时，需要使用import 语句
JavaSE OOP(面向对象)封装
weixin_44717746的博客
06-10 137
封装： 封装：面向对象三大特征之一： 将事务封装成一个类，减少耦合，隐藏细节，保留特定的接口与外界联系，当接口发生改变时，不会影响外部调用。 关于封装： 封装主要是为了增加程序的可读性，解耦合，并且隐藏部分实现细节。 案例： public class Test { public static void main(String[] args) { Student student = new Student(); student.name = "小明";
Javase—OOP基本说明2
qq_39162424的博客
11-27 222
1.参数的传递类型 基本数据类型 :pass by value(按值传递) 引用类型:pass by ref(按引用传递)（Person,int[]） 2.方法的重载（overload） 在一个类中，方法名相同，参数列表不同的一组方法称为重载方法； 3.就近原则 在作用域中访问标多个相同的标识符，那将使用就近原则访问 4.this this是
c++设计模式
weixin_44857939的博客
05-13 62
1、开闭原则 对扩展开放，对修改关闭。就是增加功能时，应该增加代码，而不应该修改原来的代码。
毕向东老师详解JavaSE：从基础到高级
面向对象编程（OOP）是Java的核心，涉及类、对象、封装、继承、多态等概念。 9. 异常处理 异常是程序运行时的错误，Java通过try-catch-finally结构来捕获和处理异常，以保证程序的健壮性。 10. 多线程 Java提供...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值