静态类和静态方法、接口和抽象类、内部类、单子设计模式

最新推荐文章于 2022-03-23 11:32:05 发布
最新推荐文章于 2022-03-23 11:32:05 发布
阅读量1.3k 收藏 3
点赞数 2
分类专栏： JAVA学习笔记
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/aiynmimi/article/details/46992171
版权

静态类和静态方法

static关键字

  1. static可以修饰类共有的变量，方法和嵌套类。
  2. static声明的属性和方法与整个类相关，而与类的任何实例无关，因此静态成员经常称为类成员，例如类属性和类方法。
  3. 静态的变量和方法可以通过类名.属性名和类名.方法名()直接调用，不需要new一个实例。
  4. 一个类的静态属性与方法能够被其他类共享，其数据存放在特定的内存空间中。
    例如：Integer类中有parseInt(String s)这个静态方法
    Integer.parseInt(String s);将字符串参数作为有符号的十进制整数进行解析

final关键字

被final修饰的类

  1. 该类不能被继承（这样可以保证类的安全）。
  2. final类中的所有方法都默认为final。

被final修饰的方法

  1. 该方法不能被重写。
  2. final方法无需支持动态绑定，因此效率更高。

被final修饰的变量

  1. 该变量一旦被赋值，值就不能被修改。
  2. 如果修饰全局变量，必须在声明的同时赋初始值。
  3. 如果修饰局部变量，可以先声明再赋值。

常量

常量定义语法：public static final int PORT_NUMBER=1;
常量命名规则：全部单词要大写，单词要用下划线隔开。

代码例子

建一个Person类

public class Person {
    public static final int EYE_NUM=2; //常量
    private int age;
    private String name;
    public static int hands=2; //静态全局变量
    public int getAge() {
        return age;
    }
    public void setAge(int age) {
        this.age = age;
    }
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    public static void run(){     //静态方法
        System.out.println("我们都会跑！");
    }
}

建一个测试类

public class Test {
    public static void main(String[] args) {
        System.out.println("我们都有"+Person.hands+"双手");
        System.out.println("我们都有"+Person.EYE_NUM+"只眼");
        Person.run();
    }
}

输出结果：
这里写图片描述

接口和抽象类

接口

接口是一些方法特征的集合，但没有方法的实现，只是声明。接口中定义的方法在不同的地方被实现，可以具有不同的行为。

接口的定义语法：

public interface 接口名{
    方法1；
    方法2；//方法的声明

接口的实现语法：

public class 类名 implements 接口名{
    方法1{}
    方法2{} //方法的实现

接口的实例化

接口名 对象名 = new 类名(实现该接口的类)();
对象名.方法名();  //调用接口声明的方法

代码例子

//创建Fly接口
public interface Fly {
    public void fly();
}

//创建Load接口
public interface Load {
    public void load();
}

//创建Plane类实现两个接口
public class Plane implements Fly,Load{
    @Override
    public void load() {
        System.out.println("我能运货");     
    }
    @Override
    public void fly() {
        System.out.println("我能飞");      
    }
}

//创建Apache类继承Plane类
public class Apache extends Plane{
}

//创建Test类
public class Test {
    public static void main(String[] args) {
        Apache apache = new Apache();
        apache.fly();
        apache.load();
    }
}

运行结果：
这里写图片描述

面向接口编程

我需要一个人去按要求打印东西
①首先需要打印机，墨盒墨水，纸张：

//创建Print接口
public interface Print {
    public void print(Ink a,Paper b);
}

//创建HPPrint类实现Print接口
public class HPPrint implements Print{
    @Override
    public void print(Ink a, Paper b) {
        System.out.println("我是惠普打印机，我用的墨盒颜色是："+a.getColor()+"  我用的纸张尺寸是："+b.getSize());     
    }
}

//创建EpsonPrint类实现Print接口
public class EpsonPrint implements Print{
    @Override
    public void print(Ink a, Paper b) {
        System.out.println("我是爱普生打印机，我用的墨盒颜色是："+a.getColor()+"  我用的纸张尺寸是："+b.getSize());        
    }
}

//创建Ink接口
public interface Ink {
    public String getColor();
}

//创建BeijingInk类实现Ink接口
public class BeijingInk implements Ink{
    @Override
    public String getColor() {
        return "北京彩色";      
    }
}

//创建ShangHaiInk类实现Ink接口
public class ShangHaiInk implements Ink{
    @Override
    public String getColor() {
        return "上海黑白";
    }
}

//创建Paper接口
public interface Paper {
    public String getSize();
}

//创建ChenGuangPaper类实现Paper接口
public class ChenGuangPaper implements Paper{
    @Override
    public String getSize() {
        return "晨光A4";
    }
}

//创建OrherPaper类实现Paper接口
public class OrherPaper implements Paper{
    @Override
    public String getSize() {
        return "其他A6";
    }
}

②准备好上述三样东西以后，就需要一个人来拿着这三样东西去打印

//创建Person类
public class Person {
    public Print cratePrint(){//得到打印机的方法
        Print print = new HPPrint();
        return print;
    }
    public Ink crateInk(){//得到墨水的方法
        Ink ink = new BeijingInk();
        return ink;
    }
    public Paper cratePaper(){//得到纸张的方法
        Paper paper = new ChenGuangPaper();
        return paper;
    }
    public void print(){
        Print print=cratePrint();
        Ink ink=crateInk();
        Paper paper=cratePaper();
        print.print(ink, paper);    
    }
}

③开始打印

//创建Test类
public class Test {//面向借口编程
    public static void main(String[] args) {
        Person zhangsan = new Person();
        zhangsan.print();
    }
}

抽象类

抽象类的定义

使用abstract关键字定义一个抽象类

public abstract class Person{//定义抽象类
    public abstract void sayHi();//声明抽象方法
}
  1. 抽象类在实例化时，要new它的子类，不能new本身。所以说抽象类是一个未定义完整的类，其中的抽象方法要延迟到子类中去实现。
  2. 一个抽象类可以没有抽象方法，也可以有多个抽象方法，但如果没有抽象方法，则给抽象类无意义。
  3. 一个普通类中不允许有抽象方法。有抽象方法，该类必须为抽象类。
  4. 如果抽象类的子类没有实现抽象类中的抽象方法，那么该子类必须为抽象类。同样的，如果接口的实现类没有实现给接口中声明的方法，则该实现类也必须定义为抽象类。

代码例子

//创建一个Person抽象类
public abstract class Person {
    public abstract void sayHi();
}

//创建Chinese类继承Person类
public class Chinese extends Person {
    @Override
    public void sayHi() {
        System.out.println("你好！");
    }
}

//创建Test类
public class Test {
    public static void main(String[] args) {
        Person p1 = new Chinese();//父类new一个子类
        p1.sayHi();
        Chinese p2 = new Chinese();//子类new一个子类
        p2.sayHi();

        Person p3 = new Person() { //匿名内部类          
            @Override
            public void sayHi() {
                System.out.println("Hello!");               
            }
        };
        p3.sayHi();     
    }
}

运行结果：
这里写图片描述

多态

  1. Open-Close原则
    当我们一个软件的需求发生改变时，我们能够以添加新的代码的方式，而不是修改原来的代码的方式来适应需求的改变，如果能做到这一点，我们就讲，这种设计满足Open-Close原则。
  2. 多态的本质
    ①父类的引用指向了自己的子类对象②必须是类与类之间只有关系，要么继承或实现接口③存在方法的重写

内部类

内部类

在一个类的内部又创建了一个类

public class ClassA {
    private int a=1;
    public void testA(){
        System.out.println("外部类的方法");
    }
    class ClassAChild{ //内部类
        private int a=2;
        public void testAChild(){
            testA();//内部类直接调用外部类的方法
            System.out.println("内部类的方法"+"  外部类的属性a="+a);//调用外部类的属性a
        }
    }   
}

//创建Test类
import lz20150721.d5.ClassA.ClassAChild;
public class Test {
    public static void main(String[] args) {
        //内部类的实例化
        ClassAChild classAChild=new ClassA().new ClassAChild();
        classAChild.testAChild();//调用内部类的方法
    }
}

运行结果：
这里写图片描述

局部内部类

public class ClassA {
    private int a;
    public void testA(){
        class ClassB{
            private int b;
            public void testB(){//定义局部内部类
                System.out.println("局部内部类的方法");
            }
        }
        ClassB classB= new ClassB();
        classB.testB();
    }
}

//创建Test类
public class Test {
    public static void main(String[] args) {
        ClassA classA = new ClassA();
        classA.testA();     
    }
}

运行结果：
这里写图片描述

匿名内部类

  1. 匿名内部类适合创建那种只需要一次使用的类。
  2. 定义匿名类不需要class关键字，而是在定义匿名内部类时直接生成该匿名内部类的对象。
  3. 最常用的创建匿名内部类的方式是需要创建某个接口类型的对象。
    例如：
//创建IA接口
public interface IA {
    public void func();
}
//创建Test类
public class Test {
    public static void main(String[] args) {
        IA a = new IA() {//匿名内部类        
            @Override
            public void func() {
                System.out.println("匿名内部类");                
            }
        };
        a.func();
    }
}

运行结果：
这里写图片描述

单子设计模式

创建方法

需求只创建一个对象，即可用单子设计模式
1. 隐藏系统的无参构造方法——>private
2. 创建一个静态的得到对象的方法。
3. 创建一个静态的本类的对象。
4. 在静态方法中添加判断语句。

代码实现

//创建Student类
public class Student {//单子设计模式
    private static Student instance;//第三步
    private Student(){//第一步

    }
    public static Student getInstance(){//第二步
        if(instance ==null){//第四步
            instance = new Student();
        }
        return instance;
    }
}

//创建Test类
public class Test {
    public static void main(String[] args) {
        Student zhangsan = Student.getInstance();
        Student lisi = Student.getInstance();
        System.out.println(zhangsan);
        System.out.println(lisi);
    }
}

运行结果：这里写图片描述
结果显示两个对象指向的地址相同，说明只创建了一个对象。

简单工厂设计模式

木大白易
关注
专栏目录
【2021-09-16】静态、抽象、内部类
给小矦来杯冰可乐
09-18 271
静态、抽象、内部类 一.static1.静态属性 一.static static 修饰符可以修饰属性、方法、代码块 1.静态属性 静态属性属于类可以直接使用类名来访问，也可以使用对象访问 非静态属性属于对象的，一定要使用对象来访问 ...
Java笔记（9）——static、静态初始化、单子模式、final关键字和抽象类
bwqiang的博客
08-09 118
1. static关键字 static：静态的，意为全局的，由该关键字标记的变量或者方法由整个类所共享。 没有对象的实例，可以使用类名.方法名()的形式访问由static修饰的类方法。 在static方法内部，只能访问类的static属性，不能访问非static属性。 因为不需要实例就可以访问static方法，因此，static方法内部也不能有this和super。 /* * 练习1：编写一个类，实现银行账户的概念， * 包含的属性有“帐号”、“密码”、“存款余额”、“利率”、“最小余额”，定义封装这些
普通类，静态类，抽象类和接口
博客
03-13 2393
普通类：可以实例化就是new一个，可以被继承，有默认的构造方法即使不写出来。静态类：不能实例化，不能被继承，没有默认的构造方法，但是有静态构造方法作用是给静态属性赋值。抽象类：不能实例化，只能被继承，被继承的时候子类必须实现抽象类中的抽象方法。接口：可以被调用，可以被继承。抽象类和接口其实很像，但是区别有二1接口可以被继承，抽象类不能2抽象类可以定义，public,protected,packag...
静态内部抽象类
nayao-net
07-11 229
有没有public static abstract class XXX{}的类? 答案应该是有. 静态内部类可以加abstract 修饰. package com.test; public static class Outer{ public static abstract class Inner{ } } static 表示可以不实例化外部类,直接使用该内部类. Ou...
静态类，抽象类，接口
Gary Zhu的专栏
01-09 1912
静态类（static class） VS 普通类（normal class） 1. 静态类不能实例化。 2  静态类不能被继承。 3. 静态类成员（包括属性和方法，下同）必须是静态的。（因为不能实例化，所以无法包含实例成员） 4. 静态类不能作为泛型参数。 5. 只有静态类才能承载扩展方法，换句话说扩展方法的载体必须包含在静态类中 实际上在把静态类编译成IL时，会在它前面添加abstr
类——静态、抽象
afloatboat的博客
09-23 440
静态Static： 静态方法： 不管类生成或未生成对象，类的静态方法都可以使用。 不实例化(对象名.方法名)，直接(类名.静态方法名) 使用格式: 类名.静态方法名 静态方法只能使用静态方法所在的类的静态数据和静态方法。 抽象Abstract: 抽象类只能作为其他类的基类，它不能直接被实例化 抽象类不能同时又是密封的 抽象类允许包含抽象成员，虽然这不是必需的。抽象成员使用abstract修饰符修饰 抽象类的基类也可以是抽象类。如果一个非抽象类的基类是抽象类，则该类必须通过覆盖(重写)来实现所有继承而来的
抽象类 接口 匿名类的区别
qazzxc111的博客
07-29 3750
1 抽象类                                                                  　　当编写一个类时，常常会为该类定义一些方法，这些方法用以描述该类的行为方式，那么这些方法都有具体的方法体。但在某些情况下，某个父类并不需要实现，因为它只需要当做一个模板，而具体的实现，可以由它的子类来实现。比如说一个长方体的表面积和一个立方体的表面积
设计模式学习之访问者模式
热门推荐
一个码农的博客
04-23 3万+
访问者模式，是行为型设计模式之一。访问者模式是一种将数据操作与数据结构分离的设计模式，它可以算是 23 中设计模式中最复杂的一个，但它的使用频率并不是很高，大多数情况下，你并不需要使用访问者模式，但是当你一旦需要使用它时，那你就是需要使用它了。 访问者模式的基本想法是，软件系统中拥有一个由许多对象构成的、比较稳定的对象结构，这些对象的类都拥有一个 accept 方法用来接受访问者对象的访问。访问者是
设计模式 -- 访问者模式（Visitor Pattern）
魔法师之家
03-23 7772
封装一些作用于某些数据结构中的各元素的操作，它可以在不改变数据结构的前提下赋予这些元素新的操作。 应用场景 对象结构比较稳定，但是需要在对象结构的基础上定义新的操作。 需要对同一个类的不同对象执行不不同的操作，但是不希望增加操作的时候改变这些类。 总结 准确识别出Visitor实用的场景，如果一个对象结构不稳定决不可使用，不然在增删元素时改动将非常巨大。 对象结构中的元素要可以迭代访问 Visitor里一般存在与元素个数相同的visit方法。 元
typescript静态方法和抽象类
weixin_41587194的博客
02-24 292
//静态方法 class Person{ public name:string; static hello:string='hello' //静态属性 constructor(name:string){ this.name=name; } study(){ //实例方法 alert(`${this.name}在学习`) } eat(){ alert(`${this.name}在吃饭`) } static sayHello(){ //静态方法 .
Java中：接口，抽象类，内部类
diaopo9520的博客
03-09 108
Java8中的接口 public interface Output { //接口里定义的成员变量只能是常量 //默认使用public static final修饰 int MAX_CACHE_LINE = 50; //接...
静态方法以及抽象类、接口的理解
renjie3274的博客
10-15 359
静态方法
java8接口默认类和静态类
qq_24991431的博客
11-13 358
public interface Iface { public static void Show() { System.out.println("静态类"); } public void noe(); default void sss() { System.out.println("默认类"); }; } 静态的调用...
C#中的抽象类和静态类
syaguang2006的专栏
11-18 1633
c#中的抽象类的特征 抽象类具有以下特性： ·    抽象类不能实例化。 ·    抽象类可以包含抽象方法和抽象访问器。 ·    不能用 sealed 修饰符修饰抽象类，因为这两个修饰符的含义是相反的。采用 sealed 修饰符的类无法继承，而 abstract 修饰符要求对类进行继承。 ·    从抽象类派生的非抽象类必须包括继承的所有抽象方法和抽象访问器的实际实现。[2] 
抽象类的内部类
另一个世界
05-04 1922
抽象类的内部类 内部抽象类
静态类无法实现接口
weixin_34107955的博客
06-08 497
接口可以除了可以包括方法外，还可以包括事件，属性，因为他们都会映射为方法！ 实际上CLR（公共语言运行时）还允许接口包括静态方法，静态字段，常数，以及静态构造器，这和接口的语义并没有矛盾！ 但是CLS（通用语言规范）不允许接口有静态成员，因为某些语言不能定义和访问静态成员，这就给语言之间的交互带来问题！ 所以C#编译器不允许接口包括静态成员！ 也就是说，其实静态类实现接口并不矛盾， ...
静态类，静态方法，静态变量与非静态之前的区别
wangsen2235068的专栏
07-13 1万+
静态类
关于抽象类与静态类的初步了解
qq_38813600的博客
12-08 522
抽象类 关于抽象方法的描述： 抽象类必须在抽象类中抽象类不能有方法的实现抽象方法不能使用private修饰符如果抽象类的子类是一个普通的类，那么必须实现（重写）父类中所有的抽象方法抽象方法是用abstract修饰public abstract void Practice();抽象方法使用override 关于抽象类的说明： 抽象类中可以有字段丶属性丶方法（普通方法，
PHP面向对象基础：接口、抽象类与静态方法解析
"这篇PHP学习记录详细探讨了面向对象编程（OOP）的基础知识，包括接口、抽象类和静态方法的使用。通过实例讲解，帮助读者理解如何在PHP中实现这些概念，以便进行面向对象的程序设计。" 在PHP中，面向对象编程是一种...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值