标签：Java 静态 代码 对象 static 面向对象编程 修饰 方法

 

static关键词

---

static关键字：可以修饰属性、方法、代码块、内部类。

一、使用static修饰属性：静态变量（或类变量）

　　1. 属性，按是否使用static修饰，又分为：静态属性 vs 非静态属性(实例变量)
　　实例变量：我们创建了类的多个对象，每个对象都独立的拥有一套类中的非静态属性。当修改其中一个对象中的非静态属性时，不会导致其他对象中同样的属性值的修改。
　　静态变量：我们创建了类的多个对象，多个对象共享同一个静态变量。当通过某一个对象修改静态变量时，会导致其他对象调用此静态变量时，是修改过了的。
　　2. static修饰属性的其他说明：
　　① 静态变量随着类的加载而加载。可以通过"类.静态变量"的方式进行调用
　　② 静态变量的加载要早于对象的创建。
　　③ 由于类只会加载一次，则静态变量在内存中也只会存在一份：存在方法区的静态域中。
　　④      类变量 　实例变量
　　类 　　 yes　 　 no
　　对象 　 yes　　  yes

 

二、用static修饰方法：静态方法

　　① 随着类的加载而加载，可以通过"类.静态方法"的方式进行调用
　　②      静态方法     非静态方法
　　类 　　 yes　　　　 no
　　对象　   yes　　　　yes
　　③ 静态方法中，只能调用静态的方法或属性
　　非静态方法中，既可以调用非静态的方法或属性，也可以调用静态的方法或属性

三、 static注意点：
　　 5.1 在静态的方法内，不能使用this关键字、super关键字
　　 5.2 关于静态属性和静态方法的使用，大家都从生命周期的角度去理解。

 

四、 开发中，如何确定一个属性是否要声明为static的？

　　 > 属性是可以被多个对象所共享的，不会随着对象的不同而不同的。
　　 > 类中的常量也常常声明为static

　　开发中，如何确定一个方法是否要声明为static的？
　　> 操作静态属性的方法，通常设置为static的
　　> 工具类中的方法，习惯上声明为static的。 比如：Math、Arrays、Collections

 

单例 (Singleton)设计模式

---

的单例设计模式，就是采取一定的方法保证在整个的软件系统中，对某个类只能存在一个对象实例

package com.atguigu.java2;
/*
 * 单例设计模式：
 * 1. 所谓类的单例设计模式，就是采取一定的方法保证在整个的软件系统中，对某个类只能存在一个对象实例。
 * 
 * 2. 如何实现？
 *      饿汉式  vs 懒汉式
 * 
 * 3. 区分饿汉式 和 懒汉式
 *   饿汉式：    
 *       坏处：对象加载时间过长。
 *       好处：饿汉式是线程安全的
 *   
 *   懒汉式：好处：延迟对象的创建。
 *           目前的写法坏处：线程不安全。--->到多线程内容时，再修改
 * 
 * 
 */
public class SingletonTest1 {
    public static void main(String[] args) {
//        Bank bank1 = new Bank();
//        Bank bank2 = new Bank();
        
        Bank bank1 = Bank.getInstance();
        Bank bank2 = Bank.getInstance();
        
        System.out.println(bank1 == bank2);
    }
}

//饿汉式
class Bank{
    
    //1.私有化类的构造器
    private Bank(){
        
    }
    
    //2.内部创建类的对象
    //4.要求此对象也必须声明为静态的
    private static Bank instance = new Bank();
    
    //3.提供公共的静态的方法，返回类的对象
    public static Bank getInstance(){
        return instance;
    }
}

单例模式的饿汉式实现

/*
 * 单例模式的懒汉式实现
 * 
 */
public class SingletonTest2 {
    public static void main(String[] args) {
        
        Order order1 = Order.getInstance();
        Order order2 = Order.getInstance();
        
        System.out.println(order1 == order2);
        
    }
}


class Order{
    
    //1.私有化类的构造器
    private Order(){
        
    }
    
    //2.声明当前类对象，没有初始化
    //4.此对象也必须声明为static的
    private static Order instance = null;
    
    //3.声明public、static的返回当前类对象的方法
    public static Order getInstance(){
        
        if(instance == null){
            
            instance = new Order();
            
        }
        return instance;
    }
    
}

单例模式的懒汉式实现 单例模式的优点：由于单例模式只生成一个实例，减少了系统性能开销，当一个对象的产生需要比较多的资源时，如读取配置、产生其他依赖对象时，则可以通过在应用启动时直接产生一个单例对象，然后永久驻留内存的方式来解决。

 

 

 

 

main方法是静态的

---

 main()方法的使用说明：

　　1. main()方法作为程序的入口
　　2. main()方法也是一个普通的静态方法
　　3. main()方法可以作为我们与控制台交互的方式。（之前：使用Scanner）

public static void main(String[] args) {}
/*
public : 被jvm调用，访问权限足够大。
static : 被jvm调用，不用创建对象，直接类名访问
void : 被jvm调用，不需要给jvm返回值
main : 一个通用的名称，虽然不是关键字，但是被jvm识别
String[] args : 以前用于接收键盘录入的
*/

 

 

代码块

---

类的成员之四：代码块（或初始化块）
一、代码块的作用：用来初始化类、对象
二、代码块如果有修饰的话，只能使用static.
三、分类：静态代码块 vs 非静态代码块

四、静态代码块
　　 >内部可以有输出语句
　　>随着类的加载而执行,而且只执行一次
　　>作用：初始化类的信息
　　>如果一个类中定义了多个静态代码块，则按照声明的先后顺序执行
　　>静态代码块的执行要优先于非静态代码块的执行
　　>静态代码块内只能调用静态的属性、静态的方法，不能调用非静态的结构
　　
五、 非静态代码块
　　>内部可以有输出语句
　　>随着对象的创建而执行
　　 >每创建一个对象，就执行一次非静态代码块
　　 >作用：可以在创建对象时，对对象的属性等进行初始化
　　 >如果一个类中定义了多个非静态代码块，则按照声明的先后顺序执行
　　 >非静态代码块内可以调用静态的属性、静态的方法，或非静态的属性、非静态的方法
　　

代码块：使用 {} 括起来的代码被称为代码块，根据其位置和声明的不同，可以分为局部代码块，构造代码块，静态代码块，同步代码块(多线程讲解)。

一、局部代码块：在方法中出现；限定变量生命周期，及早释放，提高内存利用率

二、构造代码块：在类中方法外出现；多个构造方法方法中相同的代码存放到一起，每次调用构造都执行，并且在构造方法前执行。

　　执行顺序：局部代码块——>静态代码块（static）——>构造代码块——>构造方法

　　如果代码块中包含static，无论是在父类还是子类中，都先执行静态代码块。

　　静态代码块只执行一次。

 

三、静态代码块：在类中方法外出现，加了static修饰 在类中方法外出现，并加上static修饰；用于给类进行初始化，在加载的时候就执行，并且值执行一次。

 

 

对属性可以赋值的位置：
　　 ①默认初始化
　　 ②显式初始化/⑤在代码块中赋值
　 　③构造器中初始化
　　 ④有了对象以后，可以通过"对象.属性"或"对象.方法"的方式，进行赋值

　　执行的先后顺序：① - ② / ⑤ - ③ - ④

 

 

final关键字

---

 final 可以用来修饰: 类、方法、变量。

1. final关键字修饰类：类不能被其他类继承。 

   比如：String类、System类、StringBuffer类。

2. final关键字修饰成员变量，成员变量变成了一个常量，只能赋值一次，不能被修改。                          可以考虑赋值的位置有：显式初始化、代码块中初始化、构造器中初始化
3. final修饰局部变量，在方法内部（基本数据类型），值不能修改。如果修饰引用数据类型，引用的地址值不能发生改变（例：final  Student  s = new Studen(); ）。
4. final关键字修饰方法，方法不能被重写。比如：Object类中getClass();
5. final初始化时机：在构造对象完成之前。
6. static final  用来修饰属性：全局常量

 

 

抽象类

---

一、抽象类格式：

abstract  class  类名{}
/*
用abstract关键字来修饰一个类，这个类叫做抽象类。
用abstract来修饰一个方法，该方法叫做抽象方法。
public abstract void example();
*/

二、注意事项：

　　1.抽象类不一定有抽象方法，包含抽象方法的类一定是抽象类。

　　2.抽象类不能实例化，但是可以通过子类继承，通过子类实例化。抽象类的子类必须重写父类的抽象方法，并提供方法体。若没有重写全部的抽象方法，仍为抽象类。

　　3.abstract 不能用来修饰 final 、final的类、private（私有方法）、static（静态方法）

　　4.abstract不能用来修饰变量、代码块、构造器；

public class AbstractTest2 {
        public static void main(String args[]) {
            A a = new B();
            a.m1();
            a.m2();
        }

}
abstract class A {
    abstract void m1();
    public void m2() {
        System.out.println("A类中定义的m2方法");
    } }
class B extends A {
    void m1() {
        System.out.println("B类中定义的m1方法");
    }
}
//输出：B类中定义的m1方法
//A类中定义的m2方法

抽象类举例

问题1：为什么抽象类不可以使用final关键字声明？
因为抽象类得通过子类继承，子类实例化，而final关键字就指定了类不能被继承。


问题2：一个抽象类中可以定义构造器吗？
可以

抽象类思考问题

三、抽象类的匿名子类

 

 

 

接口(interface)

---

 

一、接口（interface）格式：

interface  接口名{}

二、注意事项：

　　1.类实现接口用 implements　　　　

class 类名 implements 接口名{}

　　2.接口不能被实例化。

　　　　2.1 接口多态：由具体子类进行实例化

　　　　2.2接口的子类：要么是抽象类。要么是具体的子类，但是必须要重写接口中所有的抽象类。

总结：  1.开发中最常见的是接口多态

　　　　2.抽象多态

　　　　3.具体类

三、接口中成员

　　1.成员变量：只能是常量，而且是静态的。且有默认修饰符  public static final，如果在定义变量时没有，会自动补上。

　　2.构造方法：接口中无构造方法。

　　3.成员方法：接口中只能是抽象方法，无方法体。有默认值： public  abstract

四、类与接口的关系

　　1.类与类：继承关系。只能单继承。不能一次性继承多个，但可以多层继承。

　　2.类与接口：类可以单个实现接口，也可以一次性实现多个接口。可以在继承一个类时，实现多个接口，每个类都默认继承Object类。

　　3.接口与接口：无实现关系，只有继承关系。可单继承，也可一次性继承多个。

　　　　

 

内部类

---

 

一、内部类的定义：在Java中，允许一个类A的定义位于另一个类B的内部，前者A称为内部类，后者B称为外部类。 二、内部类的分类： 　　　1.成员内部类（static成员内部类和非static成员内部类） 　　　2.局部内部类（不谈修饰符）、匿名内部类。 三、成员内部类作为类的角色： 　　　1.可以在内部定义属性、方法、构造器等结构 　　　2.可以声明为abstract类 ，因此可以被其它的内部类继承 　　　3.可以声明为final的 　　　4.编译以后生成OuterClass$InnerClass.class字节码文件（也适用于局部内部类）

四、成员内部类作为类的成员的角色：

　　　1.可以被四种权限修饰； 　　　2.可以调用外部类的结构 　　　3. 可以被static修饰； 五、注意问题： 　　　1.如何实例化成员内部类：

实例化静态的成员内部类  内部类：A  外部类：B
B.A  具体名 =  new B.A（）；

实例化非静态的成员内部类
B.A  具体名 = B.new A（）；

 　　2.

　　　　　　

 

标签：Java,静态,代码,对象,static,面向对象编程,修饰,方法
来源： https://www.cnblogs.com/gym0/p/15354125.html

本站声明： 1. iCode9 技术分享网（下文简称本站）提供的所有内容，仅供技术学习、探讨和分享；
2. 关于本站的所有留言、评论、转载及引用，纯属内容发起人的个人观点，与本站观点和立场无关；
3. 关于本站的所有言论和文字，纯属内容发起人的个人观点，与本站观点和立场无关；
4. 本站文章均是网友提供，不完全保证技术分享内容的完整性、准确性、时效性、风险性和版权归属；如您发现该文章侵犯了您的权益，可联系我们第一时间进行删除；
5. 本站为非盈利性的个人网站，所有内容不会用来进行牟利，也不会利用任何形式的广告来间接获益，纯粹是为了广大技术爱好者提供技术内容和技术思想的分享性交流网站。