Java(三)(static,代码块,单例设计模式,继承)
目录
static
有无static修饰的成员变量
有无static修饰的成员方法
static的注意事项
代码块
静态代码块
实例代码块
单例设计模式
饿汉式单例写法
懒汉式单例写法
继承
基本概念
注意事项
权限修饰符
单继承
object
方法重写
子类方法中访问其他成员(成员变量,成员方法)
子类构造器
static
静态,可以修饰成员变量,成员方法
有无static修饰的成员变量
成员变量按照有无static修饰,分为两种:
(1)类变量: 有static修饰,属于类,在计算机里只有一份,会被类全部对象共享(每个对象都会有,只需要设置一次)
(2)实例变量(对象的变量):无static修饰,属于每个对象的(需要对每一个变量进行设置)
像上面这个图一样,static修饰的name变量是s1和s2共享的,age变量需要对s1和s2分别设置
推荐用类名访问类变量: 类名.类变量
下面是我们访问到类中的变量的流程图: 我们的类创建到方法区中,我们的类变量会被存放到堆内存中,我们new出来的对象也会放到堆内存中,我们栈内存会存放一些指令,当我们要访问age时直接到堆内存中访问修改,想访问name时会跳到方法区找到类,然后通过类访问到类变量
访问自己的类变量是可以省略不写类名的
有无static修饰的成员方法
类方法:静态方法,属于类,可以直接用类名访问,也可以用对对象访问
实例方法: 对象的方法
啥叫工具类: 工具类中的方法都是类方法, 每一个类方法都是用来完成一个功能,不需要创建对象
static修饰的成员方法一般应用在工具类中,而不是实例方法中
当我们想要调用一个类的方法的时候,仅仅只是调用方法,我们直接将这个方法指定成类方法,到时候我们想要调用这个方法的时候直接,用 类名.成员方法 就行了,就不用创建对象,在调用对象的实例的方法,如果再创建一个对象,对象会占内存,这样会浪费内存
工具类定义的时候有什么要求? 工具类不需要创建对象,建议将工具类的构造器私有化
static的注意事项
1.类方法中可以直接访问类的成员,不可以直接访问实例成员
2.实例方法既可以直接访问类成员,也可以直接访问实例成员
3.实例方法中可以出现this关键字,类方法不可以出现this关键字的
因为我们调用实例方法的时候,是用对象名.实例方法的,其实是有一个对象,this就是我们这个对象
而我们一般调用类方法的时候,一般是用类名.类方法.没有对象,那我这个this就没有指向的对象了
代码块
静态代码块
格式: static { }
特点: 类加载的时候自动执行,由于类只会加载一次,所以静态代码块也只会执行一次
作用:完成类的初始化,一般可以对类变量进行初始化赋值
但是代码块只会执行一次,只是在一开始的时候加载类的时候去执行,我们在下面进行验证
实例代码块
格式 : { }
特点: 每次创建对象时,执行实例代码块,并在执行构造器前执行
单例设计模式
饿汉式单例写法
调用类方法的时候,对象已经创建了的
public class Student {
// 1.必须私有类的构造器
private Student()
{
}
// 2.定义一个类变量记住类的一个对象
private static Student a = new Student();
//3.定义一个类方法返回类的对象
public static Student getObject()
{
return a;
}
创建唯一的一个对象
懒汉式单例写法
第一次调用方法就创建这个对象,以后调用的时候都返回这个对象
import org.w3c.dom.ls.LSOutput;
public class Student {
// 1.把类的构造器私有
private Student()
{
}
// 2. 定义一个类变量,用于储存这个类的一个对象
private static Student s1;
// 3. 定义一个类方法,这个方法要保证第一个调用时
// 才创建一个对象,后面调用的时候都会返回一个对象
public static Student getObject()
{
if(s1 == null)
{
s1 = new Student();
}
return s1;
}
}public class test {
public static void main(String[] args) {
Student stu1 = Student.getObject();
Student stu2 = Student.getObject();
System.out.println(stu1 == stu2);
}
}我们发现打印出来的结果是true,说明这个设计模式仅仅创建了一个对象
继承
基本概念
Java中提供了一个关键字extends,这个关键字,可以让一个类和另一个类建立起父子关系
继承的特点: 子类能继承父类的非私有成员(成员变量,成员方法)
继承后对象的创建: 子类的对象是由子类,父类共同完成的
我们可以用继承来简化代码,不让代码那么繁琐
假若说我要写两个对象,第一个是老师,老师的数据有名字,具有的技能
第二个是快递员,快递员的数据有名字,送快递的单数
我们要创建两个对象的话一般会按照下面这样来创建
// 快递员对象
public class Courier {
private String name;
private int number;
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public int getNumber() {
return number;
}
public void setNumber(int number) {
this.number = number;
}
}
// 老师对象
public class Teacher {
private String name;
private String skill;
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public String getSkill() {
return skill;
}
public void setSkill(String skill) {
this.skill = skill;
}
}
我们会发现:老师和快递员都会有一个相同的成员属性:名字
我们可以整一个父类,父类People对象中有neme方法,让老师对象和快递员对象都继承得到父类的公共属性和方法
// 快递员的对象
public class Courier extends People {
private int number;
public int getNumber() {
return number;
}
public void setNumber(int number) {
this.number = number;
}
}// 老师对象
public class Teacher extends People{
private String skill;
public String getSkill() {
return skill;
}
public void setSkill(String skill) {
this.skill = skill;
}
}
当我们创建老师对象的时候也会访问到父类中的共有方法,通过共有方法,我们就可以设置老师的姓名
public class test {
public static void main(String[] args) {
Teacher t1 = new Teacher();
t1.setName("李小谦");
System.out.println(t1.getName());
t1.setSkill("爱讲物理课");
System.out.println(t1.getSkill());
}
}注意事项
权限修饰符
public private protected 缺省
权限的大小关系: public > protected > 省略 > private
下面是他们的访问范围
单继承
Java是单继承的,一个类只能继承一个直接父类,Java中的类不支持多继承,但是支持多层继承的
但是支持多继承
class A{}
class B extends A{}
class C extends B {}object
object类是Java中所有的类的祖宗
我们在设计类的时候,会默认指定object类的子类
方法重写
啥是方法重写?
当子类觉得父类中的某个方法不好用,或者满足不了自己的需求时,子类可以重写一个方法名称,参数列表一样的方法,去覆盖父类的这个方法,这就是方法重写
注意:重写后,方法的访问Java会遵循就近原则
我们先来展示一下什么是方法重写
当我们创建一个C对象的时候,调用print1和print2实例方法的时候,会打印重写方法里面的内容
尽量在上面标注一个@Override,表示我们在改写父类中的方法
子类方法中访问其他成员(成员变量,成员方法)
按照就近原则
子类构造器
特点: 子类的全部构造器,都会先调用父类的构造器,再执行自己
子类构造器是如何实现调用父类构造器的?
默认情况下,子类全部构造器的第一行代码都是super()(写不写默认都是有的),他会调用父类的无参数构造器,如果父类没有无参数构造器,则我们必须在子类构造器中的第一行手写super(里面带有参数,和父类中有参数构造器中的参数一一对应)
我们来看看执行结果
假如说我将父类构造器改为有参数构造器,变成下面这样
那我们也必须在子类中手写一个带参数super(),才能执行子类构造器的代码
我们看看问什么这么做呢?
