java 静态 单例_第二十七节：Java基础面向对象-静态，单例模式，继承详情知识点...

标题图

前言

Java基础面向对象-静态，单例模式，继承详情知识点。静态-static关键字，static变量，静态代码块，代码块(不加静态)，对象创建过程，单例模式，继承。

静态-static关键字

// 定义类

class Person {

// 定义name,age属性

private String name;

private int age;

// 定义有参数的构造方法

Person(String name, int age){

this.name = name;

this.age = age;

}

// 定义方法

public void speak(){

System.out.println("name="+this.name+",age="+this.age);

}

}

// 定义方法

public void sleep(){

System.out.println("睡觉");

}

}

class PersonDemo{

public static void main(String[] args){

// 实例化对象

Person p = new Person("dashucoding",12);

// 调用功能

p.speak();

p.sleep();

}

}

在以上的代码中，我们会遇到这种情况，创建了一个对象，但是调用功能时，没有调用到对象中的数据，那么为啥还要调用呢？创建对象不就是为了封装数据的吗？

对象的创建为了产生实例，进行实例化对象进行调用，那么如果调用功能没有调用到对象中的数据，那么如果实例化很多对象时，不是浪费了堆内存中的空间了吗？这个问题值得我们深入研究。

问题解决

创建对象就会浪费内存，那就加入static使用，这个是修饰符，为静态，被static修饰的为静态方法，可以直接被类名调用，当然也是可以被对象调用的。

// 定义方法

public static void sleep(){

System.out.println("睡觉");

}

}

class PersonDemo{

public static void main(String[] args){

// 类的调用

Person.sleep();

}

}

static修饰成员变量，即为静态成员变量；修饰方法，为静态方法，修饰类，为静态类。静态方法只能访问静态变量，不能访问非静态的。

// 定义方法，给添加个static

public static void speak(){

System.out.println("name="+this.name+",age="+this.age);

}

}

// 结果报错

错误：无法从静态上下文中引用非静态 变量

static解决了不用创建对象的问题，将方法改为静态，可让功能不需要访问类中定义的成员变量，就不用创建对象来浪费空间了。所以在Java中静态的添加就是为了解决这些问题。

静态方法是注意事项

在静态方法中随着类的加载而加载，随着类的消失而消失；我们可知静态方法不能访问非静态的，可被类名直接调用，而且在静态方法中不能出现this，super的关键字。

我们如何去记住呢？this,super关键字为啥呢？

因为静态先存在内存中，此时对象有可能不存在，所以证名了，静态方法被类名直接调用，如果对象不存在；this和super关键字也一样，没有对象，哪来的this，super啊！

public static void main

class Person{

public static void main(String[] args)

{

System.out.println("hello");

new Person.run();

}

}

void run(){

Sytem.out.println("run);

}

在static修饰中，不需要对象，直接用类名就可以访问函数。在静态方法中可以调用非静态方法，一创建对象，而调用类名。

static变量

private static double pi = 3.14;

用静态修饰变量的值，每个对象需要用时，就可改为静态。

变量：静态变量，成员变量，局部变量

静态变量

成员变量

静态变量属于类

成员变量属于对象

静态变量，类变量

成员变量，实例变量

可对象或类调用

对象调用

存储在方法区中

存储在堆内存中

内存

内存：方法区，栈，堆。

静态代码块

class Demo{

// 静态变量，先加载静态变量，默认初始化，显示初始化

static int x = 3;

// 静态代码块，静态变量显示初始化后执行

static

{

System.out.println("类加载的静态代码块"+x);

}

// 静态方法

static void show()

{

System.out.println("show");

}

}

class StaticDemo{

public static void main(String[] args){

Demo.show();

Demo.show();

}

}

// 结果

类加载的静态代码块3

show

show

静态代码块是随着类的加载而加载，只加载一次，给类进行初始化的作用。

代码块(不加静态)

class Demo{

int x = 3;

{

System.out.println("run"+x);

}

Demo(){

System.out.println("demo run");

}

Demo(int x){

System.out.println("demo run int "+x);

}

}

class NoDemo{

public static void main(String[] args){

new Demo();

new Demo(4);

}

}

// 称为构造代码块

{

...

}

在构造代码块中，只要创建对象就会被调用，构造代码块为所有对象进行初始化，构造函数只针对对应的对象进行初始化。当调用对象时，构造代码块都会被调用。

{

int x = 5;

System.out.println("局部代码块"+x);

}

对于局部代码块可以控制局部变量，当代码块调用完后，局部变量就被释放。

对象创建过程

class Demo{

// 定义静态变量

static int x=2;

// 定义变量

int y =3;

// 静态代码块

static {

System.out.println("static code"+x);

}

// 构造代码块

{

System.out.println("code"+y);

}

// 构造函数

Demo(){

System.out.println("demo"+y);

}

}

class CreateDemo{

public static void mian(String[] args){

// 实例对象

Demo demo = new Demo();

}

}

调用对象时，先显示静态的代码块，在显示构造的代码块，接着显示构造函数内的代码，按照顺序打印。静态代码块执行，仅执行一次，不管调用多少次对象，都是一次。

单例模式

什么是设计模式，这是软件工程师为了解决某一问题提出的解决想法，设计模式共有23种，也可自己多想出来几种，学习其中一种单例模式。

单例模式：多个程序要使用同一个配置文件，实现数据共享等，就需要将数据封装到一个对象中，然后进行操作。

单例设计模式就是在某一个类中，在整个应用中，有且只有一个实例(对象)，即是一个类中只有一个对象实例。

class Singleton{

// 对象

static Singleton s = new Singleton();

// 私有化构造器

private Singleton(){}

// 返回该对象

static Singleton getInstance(){

return s;

}

}

步骤：

1): 私有化构造器；

2): 自身事先提供好一个对象(private static final)；

3): 向外暴露一个公共的静态方法,用于返回该对象。

饿汉式，一上来就吃

class Single{

private static final Single s = new Single(0;

private Single(){}

public static Single getInstance(){

return s;

}

}

// 懒汉式，延迟加载方式

class Single2{

private static Single2 s2 = null;

private Single2(){}

public static Single2 getInstance(){

if(s2==null){

s2 = new Single2();

}else{

return s2;

}

}

}

实例：

class Man{

private String name;

Man(String name){

this.name = name;

}

public void setName(String name){

this.name = name;

}

public String getName(){

return this.name;

}

public void fly(){

System.out.println(this.name+"fly");

}

}

class Test{

public static void main(String[] args){

// 唯一

Man man = new Man("dashu");

man.fly();

}

}

个类中只有一个对象实例

class Man{

private String name;

// 单例模式

private static Man man = new Man("dashu");

private Man(String name){

this.name = name;

}

public static Man getInstance(){

return man;

}

// 模式

public void setName(String name){

this.name = name;

}

public String getName(){

return this.name;

}

public void fly(){

System.out.println(this.name+"fly");

}

}

class Test{

public static void main(String[] args){

// 唯一

Man man = new Man("dashu");

man.fly();

}

}

// 模式

Man man1 = Man.getInstance();

Man man2 = Man.getInstance();

man1.setName("dashucoding");

man2.fly();

继承

继承提高了代码的复用性，给类和类提供了关系。在Java中允许单继承，不能多继承，单继承，一个子类只能有一个父类。但Java中支持多重继承。

class Student{

String name;

int age;

void study(){

System.out.println("study");

}

}

class Worker{

String name;

int age;

void work(){

System.out.println("work");

}

}

继承案例：

class Person{

String name;

int age;

}

class Student extends Person{

void study(){

System.out.println("study");

}

}

class Worker extends Person{

void work(){

System.out.println("work");

}

}

多重继承

class A{}

cass B extends A{}

class C extends B{}

结语

本文主要讲解 Java基础面向对象-静态，单例模式，继承详情知识点

下面我将继续对Java、 Android中的其他知识 深入讲解 ，有兴趣可以继续关注

小礼物走一走 or 点赞

送❤