前言

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中静态的添加就是为了解决这些问题。

静态方法是注意事项

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

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

因为静态先存在内存中,此时对象有可能不存在,所以证名了,静态方法被类名直接调用,如果对象不存在;thissuper关键字也一样,没有对象,哪来的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 点赞

第二十七节:Java基础面向对象-静态,单例模式,继承详情知识点的更多相关文章

  1. 九、Java基础---------面向对象封装、继承、多态

    封装 1.1 基本概念  封装(encapsulation)是面向对象三大特征之一,它是指将对象的状态信心隐藏在对象的内部,不允许外部直接进行访问,而是通过该类提供的方法来实现对内部信息的操作和访问. ...

  2. 转转转!!java基础一些静态代码块等知识点

    一.代码块: 构造代码块------类中方法的外面:每次调用构造方法都执行: 静态代码块------类中方法的外面,括号前加上static:只执行一次,随着类的加载而执行: static代码块.构造代 ...

  3. Java基础-面向对象第二特征之继承(Inheritance)

    Java基础-面向对象第二特征之继承(Inheritance) 作者:尹正杰 版权声明:原创作品,谢绝转载!否则将追究法律责任. 一.继承的概述 在现实生活中,继承一般指的是子女继承父辈的财产.在程序 ...

  4. Java基础-面向对象第三大特性之多态(polymorphism )

    Java基础-面向对象第三大特性之多态(polymorphism) 作者:尹正杰 版权声明:原创作品,谢绝转载!否则将追究法律责任. 一.多态概述 多态是继封装,继承之后,面向对象的第三大特性,多态的 ...

  5. Java基础-面向对象第一特性之封装(Encapsulation)

    Java基础-面向对象第一特性之封装(Encapsulation) 作者:尹正杰 版权声明:原创作品,谢绝转载!否则将追究法律责任. 一.理解什么是面向过程和面向对象 面向过程与面向对象都是我们编程中 ...

  6. 黑马程序员:Java基础总结----静态代理模式&动态代理

    黑马程序员:Java基础总结 静态代理模式&动态代理   ASP.Net+Android+IO开发 . .Net培训 .期待与您交流! 静态代理模式 public  class  Ts {   ...

  7. centos samba/squid 配置 samba配置 smbclient mount fstab自动挂载samba curl -xlocalhost:3128 www.qq.com squid配置 3128 DNSPOD 第二十七节课

    centos  samba/squid 配置  samba配置 smbclient  mount fstab自动挂载samba curl -xlocalhost:3128 www.qq.com squ ...

  8. 风炫安全WEB安全学习第二十七节课 XSS的防御措施

    风炫安全WEB安全学习第二十七节课 XSS的防御措施 XSS防御措施 总的原则 控制好输入/输出 过滤:根据业务需求进行过滤,对email,手机号码这样的输入框进行验证. 转义:所有输出到前端的数据都 ...

  9. java基础面向对象之类与对象

    java基础面向对象之类与对象 2017-01-14 1.面向对象的基本概念 以一种组建化的形式进行代码设计 1)在面向对象程序设计中包含有如下几种特性 •封装性:保护内部结构的安全性 •继承性:在已 ...

随机推荐

  1. Python 高阶函数map(),filter(),reduce()

    map()函数,接收两个参数,一个是函数,一个是序列,map()把传入的函数依次作用于序列的每个元素,并把结果作为新的序列返回: aa = [1, 2, 3, 4, 5] print("ma ...

  2. ubuntu彻底卸载软件

    找到此软件名称,然后sudo apt-get purge ......(点点为为程序名称),purge参数为彻底删除文件,然后sudo apt-get autoremove,sudo apt-get ...

  3. Beta冲刺——第三天

    beta冲刺:第三天 各个成员今日完成的任务 成员 冯晓.马思远 彭辉.王爽 吴琼.郝延婷 今日完成任务 ·管理员管理功能模块下角色管理功能的完善测试 ·角色和权限部分代码规范 ·博客撰写 ·后台系统 ...

  4. CSS 图像居中对齐

    CSS  图像居中对齐 我们在<CSS 内外边距>学过内容居中,它的原理是将外边左右设置为auto.图像居中也是这个原理. 示例 <!DOCTYPE html> <htm ...

  5. python入门 -- 学习笔记2

    习题11:提问 --  接受键盘的输入  raw_input input() 和 raw_input() 有何不同? input() 函数会把你输入的东西当做 Python 代码进行处理,这么做会有安 ...

  6. jQuery的appendTo案例

    案例要求:点击双击第一个下拉列表框的选项可以把对应选项移到第二个下拉列表框中,选中第一个列表框的选项(可多选)单击-->按钮可使被选中项移动到右边下拉列表框中,单击==>按钮时将左边的所有 ...

  7. vue初体验

    作为一个前端的小菜鸟,在平时的开发与学习中,除了要深入了解javascript 及 css 的各种特性,熟悉一门框架也是必不可少的.vue以其小巧,轻便,学习平滑等各种特性深受欢迎. 这里总结一下小菜 ...

  8. hive的常用操作

    1.hive的数据类型 tinyint/smallint/int/bigint tinyint:从 0 到 255 的整型数据 smallint:从 0 到 65535 的整型数据 int:从 0 到 ...

  9. SSM框架整合思想

    -------------------siwuxie095                                 SSM 框架整合思想         1.SSM 框架,即 SpringMV ...

  10. 560. Subarray Sum Equals K 求和为k的子数组个数

    [抄题]: Given an array of integers and an integer k, you need to find the total number of continuous s ...