Java基础学习（三）

最新推荐文章于 2024-07-20 23:55:03 发布
最新推荐文章于 2024-07-20 23:55:03 发布
阅读量641 收藏
点赞数 1
分类专栏： java笔记 文章标签： java 开发语言 后端
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_43954793/article/details/122639676
版权

Java基础学习（三）

1.类变量（静态变量）和类方法（静态方法）static

  1. 类变量是所有类对象共享的，类变量可以通过类名.类变量和对象名.类变量来访问，但通常使用类名.类变量
    类变量是在类加载时就创建了，所以我们没有创建对象实例时，也可以通过类名来访问类变量
  2. 静态方法类似于静态变量，开发自己的工具类时，通常使用静态方法，方便使用。静态方法中不能使用this 和super。只能访问静态变量和静态方法。
package com.static_;

public class TestStatic {
    public static void main(String[] args) {
        Student curry = new Student("Curry");
        curry.count++;
        Student tom = new Student("Tom");
        tom.count++;
        Student car = new Student("Car");
        car.count++;
        System.out.println(curry.count);  //3
        System.out.println(tom.count);   //3
        System.out.println(car.count);   //3
        System.out.println(Student.count);  //3

    }
}

class  Student{
    private String name;
    public static int count;

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

2.代码块

2.1普通代码块

  • 代码块属于初始化块，属于类中的成员，类似与方法，将逻辑语句封装在方法体中。
  • 把相同的语句，放在一个代码块里，不管调用哪个构造器，创建对象，都会优先调用代码块内容
  • 代码块调用的顺序优先于构造器
  • 当创建一个子类对象，父类的构造器也被调用，所以父类中的代码块也会被调用。
package com.codeblock_;

public class CodeBlock01 {
    public static void main(String[] args) {
        Movie movie = new Movie("蜘蛛侠");
        //结果：
//        电影屏幕打开
//        广告开始
//        电影屏幕打开
//         播放蜘蛛侠
        Movie movie1 = new Movie("唐探3", 20, "陈");
        //结果
//        电影屏幕打开 
//        广告开始
//        电影屏幕打开
//        播放唐探3

    }

}
//把相同的语句，放在一个代码块里，不管调用哪个构造器，创建对象，都会优先调用代码块内容
//代码块调用的顺序优先于构造器
class Movie {
    {
        System.out.println("电影屏幕打开");
        System.out.println("广告开始");
        System.out.println("电影屏幕打开");
    }

    private String name;
    private double price;
    private String director;

    public Movie(String name) {
        this.name = name;
        System.out.println("播放"+ name);
    }

    public Movie(String name, double price) {
        this.name = name;
        this.price = price;
        System.out.println("播放"+ name);
    }

    public Movie(String name, double price, String director) {
        this.name = name;
        this.price = price;
        this.director = director;
        System.out.println("播放"+ name);
    }
}

2.2静态代码块

  • static代码块也叫静态代码块，作用就是对类初始化，而且随着类的加载而执行，并且只会执行一次，如果是普通代码块，每创建一个对象就执行。
  • 调用类的静态成员，静态代码块会被调用。
  • 调用子类的静态成员，父类的静态代码块也会被调用。
  • 使用类的静态成员，普通代码块不会被调用。
package com.codeblock_;

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

        AA aa = new AA();
        /*输出：
        BB的静态代码块1被执行
        AA的静态代码块1被执行
         */
        System.out.println(Cat.n1);
        /*输出：
        Animal的静态代码块1被执行
        Cat的静态代码块1被执行
        30
         */

    }


}
class Animal {
    static {
        System.out.println("Animal的静态代码块1被执行");
    }
}
class Cat extends Animal{
    public  static int n1 = 30;
    static {
        System.out.println("Cat的静态代码块1被执行");
    }
}
class BB {
    static {
        System.out.println("BB的静态代码块1被执行");
    }

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

-创建一个对象时，调用的顺序为
1.调用静态代码块和静态属性初始化。（优先级一样，按定义的顺序调用）。
2.调用普通代码块和普通属性初始化。（优先级一样，按定义的顺序调用。）
3. 构造器。

package com.codeblock_;

public class CodeBlock03 {
    public static void main(String[] args) {
        A a = new A();
//        结果：
//        getN1被调用
//        A 的静态代码块被调用
//        A的普通代码块被调用%$
//        getN2被调用
    }
}

class A{
    {
        System.out.println("A的普通代码块被调用");
    }
    private int n2 = getN2();
    private static int n1 = getN1();
    static {
        System.out.println("A 的静态代码块被调用");
    }
    public  static int getN1() {
        System.out.println("getN1被调用");
        return 100;
    }
    public int getN2() {
        System.out.println("getN2被调用");
        return 100;
    }
}

2.3 创建一个对象时调用顺序的总结

父类静态代码和静态属性初始化->子类静态代码和静态属性初始化->父类普通代码块和普通属性初始化->父类构造方法->子类的普通代码块和普通属性初始化->子类的构造方法。

3.final关键字

  • 被final修饰的类不能被其他类继承
  • 被final修饰的方法不能被子类重写，可以被继承
  • 被final修饰的属性不能被修改
  • final修饰的属性可以在定义时、代码块、构造器中赋值。
  • 被static修饰的final属性只能在定义和静态代码块中赋值
  • final和static搭配使用，不会导致类加载
package com.codeblock_;

public class CodeBlock04 {
    public static void main(String[] args) {
        System.out.println(Demo.i); //16
    }

}

class Demo {
    public static final int i = 16;
    static {
        System.out.println("demo被加载");
    }
}

4.abstract

  • 当类的方法没有实现，只有定义时，用abstract修饰该方法，这个方法是抽象方法，同时要用abstract修饰该类，该类为抽象类。
abstract class Animal{
	String name;
	int age;
	abstract public void cry();
}
  • 抽象类不能被实例化
  • 如果一个类继承了抽象类，必须实现抽象类的所有抽象方法，否则也要定义为抽象类。

5.接口

结构

interface InterfaceName{
    //属性
    //方法（抽象方法，默认实现方法，静态方法）
    void function();
    default void function1(){};
    static void function2() {};
}
  • 普通类使用接口必须实现接口中的所有方法
  • 接口不能被实例化
  • 抽象类实现接口可以不实现接口中所有方法
  • 一个类可以实现多个接口
  • 接口中的方法默认为public abstract
  • 接口中的属性默认为public static final
  • 接口和接口之间是继承关系

6.内部类

  • 内部类可以直接访问外部类私有属性
  • 分类
    定义在类局部位置上（比如方法内）
    1 局部内部类（有类名）
    2 匿名内部类（没有类名）
    定义在类的成员位置上
    1 成员内部类 （没用static修饰）
    2 静态内部类 （使用static修饰）

6.1 局部内部类

  • 可以直接访问外部类的所有成员，包含私有的
  • 不可以添加访问修饰符，因为他的地位就是一个局部变量，但可以使用final
  • 作用域：仅仅在定义它的方法或代码块中
  • 访问外部类中的成员：直接访问
  • 外部类在方法中，可以创建内部类对象，然后调用内部类成员
  • 外部其他类，不能访问内部类
  • 如果外部类与局本内部类的成员重名，遵循就近原则，如果想访问外部类成员，使用外部类名.this.成员
package com.innerclass;

public class LocalInnerClass {
    public static void main(String[] args) {
        Outer r = new Outer();
        r.m1();
    }

}

class Outer{
    private int n1 = 100;
    private void m2() {
        System.out.println("m2被调用");
    }

    public void m1() {
        //不可以添加访问修饰符，因为他的地位就是一个局部变量，但可以使用final
        //作用域：仅仅在定义它的方法或代码块中
        //外部类在方法中，可以创建内部类对象，然后调用内部类成员
       final class Inner{
           private  int n1 = 800;
            public void f1(){
                System.out.println("Inner 的 n1 =" + n1);
                System.out.println("Outer 的 n1 =" + Outer.this.n1);//可以直接访问外部类的所有成员，包含私有的
                m2();                     //访问外部类中的成员：直接访问
            }
        }
        new Inner().f1();
    }
}

6.2 匿名内部类

  • 相当于继承了类或实现了接口
package com.innerclass;

public class AnonymousInnerClass {
    public static void main(String[] args) {
        Outer01 outer01 = new Outer01();
        outer01.method();

    }
}

class Outer01 {
    private int n1 = 10;

    public void method() {
        //基于接口的匿名内部类
        //类只使用一次，以后不再使用
        //tiger 的编译类型 A
        //tiger 的运行类型 匿名内部类


       A tiger =  new A() {
            @Override
            public void cry() {
                System.out.println("老虎叫。。。。");
            }
        };
       Father father = new Father("jack"){
           @Override
           public void test() {
               System.out.println("匿名内部类的test");
           }
       };
       tiger.cry();
       father.test();
    }

}

interface A {
    public void cry();
}

class Father {
    public Father (String name){

    }
    public void test() {}
}

6.3 成员内部类

  • 可以访问外部类的所有成员
  • 可以添加访问修饰符
package com.innerclass;

public class MemberInnerClass {
    public static void main(String[] args) {
        Outer02 outer02 = new Outer02();
        outer02.t1();
        Outer02.Inner02 inner02 = outer02.new Inner02(); //创建内部类对象
        inner02.say();

    }
}
class Outer02 {
    private int n1 = 10;
    public String name = "张三";
    class Inner02 {
        public void say() {
            System.out.println("n1 = " + n1 + " name  =  " + name);
        }
    }
    public void t1() {
        Inner02 inner02 = new Inner02();
        inner02.say();
    }
}

6.4 静态内部类

  • 只能访问外部类的静态成员，不能访问非静态成员。
  • 可以添加访问修饰符
  • 可以直接通过外部类名访问
package com.innerclass;

public class StaticInnerClass {
    public static void main(String[] args) {
        //两种创建内部类的方法
        Outer03.Inner03 inner03 = new Outer03.Inner03();
        inner03.say();

        Outer03.Inner03 inner031 = Outer03.Inner03.getInstance();
        inner031.say();

    }
}

class Outer03 {
    private int n1 = 10;
    private static String name = "jack";

    static class Inner03 {
        //只能访问外部类的静态成员，不能访问非静态成员。
        //可以添加访问修饰符
        public void say() {
            System.out.println(name);
        }

        public static Inner03 getInstance() {
            return new Inner03();
        }
    }
}
南北有东西
关注
  • 1
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
Java基础 学习笔记 Markdownr版
06-27
本学习笔记主要涵盖了Java的基础知识，包括面向对象、集合、IO流、多线程、反射与动态代理以及Java 8的新特性等方面，旨在帮助初学者或有经验的开发者巩固和提升Java编程技能。 1. 面向对象（OOP）：Java的核心是...
面向对象下——抽象类
xing_xin_99的博客
01-01 235
抽象类 类中的某些方法需要声明，但又不确定该如何实现时可以将其声明为抽象方法，而声明了抽象方法的类就是抽象类 即抽象方法是指没有实现的方法（没有方法体），当一个类中存在抽象方法时需要将该类声明为抽象类，而抽象方法的具体实现是由子类来完成 public abstract class Animal{ String name; int age; abstract public void cry(); //抽象方法的具体实现由子类重写来完成 } 语法 抽象类 访问修饰符 abstract
java===java基础学习（15）---抽象，接口
软件测试技术的博客
04-16 72
抽象 //这就是一个抽象类 abstract class Animal { String name; int age; abstract public void cry(); } //当一个类继承的父类是抽象的话 //需要我们把继承类中的所有方法全部实现 class cat extends Animal { public void c...
java基础入门笔记（二）
green703338130的博客
10-14 646
抽象类使用关键字abstract声明的类，使用abstract声明的成员方法称为抽象方法，抽象方法只有方法没有方法体，需要在子类中去实现。public abstract class CloseFigure { public abstract double area(); }抽象类不能被实例化，既不能创建抽象类的实例；CloseFigure g=new CloseFigure();//语法错误
Java基础学习
05-09
Java基础学习，Java基础学习，Java基础学习，Java基础学习
Java基础学习Java基础学习
01-17
Java基础学习Java基础学习Java基础学习Java基础学习Java基础学习Java基础学习Java基础学习Java基础学习Java基础学习Java基础学习Java基础学习Java基础学习Java基础学习Java基础学习Java基础学习Java基础学习Java基础...
Java基础学习资源
01-05
适合Java零基础人员，主要内容是串了一遍Java基础，主要内容为本人学习过程中做的一些笔记，打开需要用markdown
Java 基础知识学习文档
07-04
【Java基础知识学习文档】 Java是一种由Sun Microsystems公司（现已被Oracle公司收购）的詹姆斯·高斯林（James Gosling）创建的高级编程语言，自1995年发布以来，因其可移植性、安全性和高性能而备受推崇。Java...
Java内存模型
weixin_44267758的博客
07-19 663
此处的变量不是指java编程中的变量，它包括了实例字段，静态字段和构成数值对象的元素，但不包括局部变量和方法参数。JMM规定所有变量都存储在主内存中。每条线程有自己的工作内存，工作内存中保留了该线程使用到变量的主内存的副本。线程对变量的所有操作都必须在工作内存中进行，不能直接读写主内存的变量，不同的线程间也无法直接访问对方工作内存的变量，线程之间的变量值传递需要通过主内存来完成。
Promise 详解（原理篇）
最新发布
山重水复疑无路，柳暗花明又一村。
07-20 485
Promise 是一种异步编程的解决方案。在异步操作中，callback 会导致回调地狱的问题，Promise 解决了这个问题。一个 Promise对象有以下三种状态:pending：初始状态，既不是成功，也不是失败状态。：意味着操作成功完成。rejected：意味着操作失败。当 new Promise() 被实例化后，即表示 Promise 进入 pending 初始化状态，准备就绪，等待运行。
JVM-垃圾回收与内存分配
m0_50846237的博客
07-19 1119
JVM-垃圾回收与内存分配
java算法day19
TOMOT77的博客
07-20 172
我第一时间想到的方法是遍历二叉树+哈希。哈希用来统计数字出现的次数。之后遍历map收集结果。利用了BST的性质，即BST的中序序列是有序序列。
【Java算法】前缀和 下
2302_79806056的博客
07-18 1045
这段代码实现了一个寻找数组中具有相等数量的0和1的最长子数组长度的算法。具体来说，它使用了前缀和（prefix sum）的概念以及哈希映射（HashMap）来优化查找过程。初始化哈希映射：计算前缀和：检查相等数量的0和1：更新哈希映射：返回结果：这种方法的时间复杂度为O(n)，因为我们只遍历数组一次，并且对每个元素执行常数时间的操作。空间复杂度也是O(n)，最坏情况下需要存储n个前缀和值。 初始化阶段:开始遍历数组:继续
Java实验2
qq_64727229的博客
07-16 535
类的封装、继承、多态和接口（1）有理数四则运算（2）最终得分
每 日练 习
m0_67187271的博客
07-19 795
正确答案：C 解析：是正确的，这是最基本的类定义形式，没有继承任何类，也没有实现任何接口。也是正确的，这里定义了一个名为x的类，它继承了名为y的类。同样是正确的，这里定义了一个公共类x，它继承了Applet类，这在Java中是合法的，尤其是在创建GUI应用程序时常见。是不正确的，因为在Java中，我们不能使用static关键字来修饰一个类的定义。static关键字只能用于类的方法、变量或者是内部类（即嵌套类），但不能用于顶级类（非嵌套类）。所以，这个选项是错误的。因此，正确答案是C。
对androidTestDebug 产物进行重新签名
shuizhizhiyin的专栏
07-19 463
在运行 gradle assembleAndroidTestDebug 任务后，自定义的 reSignAndroidTestDebug 任务将会被执行，并对子模块的 androidTestDebug 产物进行重新签名。your_keystore_path.jks、your_keystore_password、your_key_alias 和 your_key_password 需要替换为你的实际路径和密码。如果需要对其他子模块的产物进行重新签名，可以根据需要创建不同的自定义任务。// 设置密钥库密码。
Srping Cloud - @Async注解+Feign手动设置token
qq_36782325的博客
07-16 273
在Spring cloud项目开发中，经常需要通过feign远程调用其他的服务的方法。有时因为跨服务调用的时间较长，就会存在需要异步跨服务调用的场景，此时就会出现请求头（主要是token）丢失的问题。
《简历宝典》15 - 简历中“项目经历”，实战讲解，Java篇
xingyu_qie的专栏
07-18 227
校招和初级Java开发的项目经历重点是突出自己在实战中的学习。比如对数据库的操作，比如前后端联调工作中遇到问题的解决，比如一些Java基础知识点的逐渐深入掌握，这些都是这个阶段的Java开发需要去不断增强的。和初级前端开发类似，例如你作为一名初级Java开发，负责的是校园图书管理系统的图书信息上传，图书信息管理这个模块的服务端开发，项目经历可以这样编写，如图。
python--实验14 并发编程（多线程）
wumingzei的博客
07-18 942
定义通过声明Thread的派生类，创建一个子类，并重写对象的run方法，然后创建其对象实例，可创建线程。通过对象的start方法，可启动线程，并自动执行对象的run方法。注意子类的构造器一定要先调用基类的构造器直接将线程需要做的事写到run方法中示例。
Java基础学习与环境搭建详解
"这是一份详尽的Java入门学习笔记，涵盖了Java基础知识、语言概述、环境搭建及程序执行流程。" Java作为一门广泛使用的编程语言，其基础知识是学习者必须掌握的关键部分。首先，软件开发涉及将一系列特定顺序的指令...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

南北有东西

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值