高级类特性-static关键字-设计模式（单例）-final关键字-abstract(抽象类)

最新推荐文章于 2023-12-29 16:51:05 发布

置顶程序小问题

最新推荐文章于 2023-12-29 16:51:05 发布

阅读量365

点赞数 2

分类专栏：类文章标签： java 设计模式抽象类

本文链接：https://blog.csdn.net/weixin_44435366/article/details/107387687

版权

类专栏收录该内容

3 篇文章 0 订阅

订阅专栏

高级类特性

static

属性（成员变量）静态属性，类属性

方法静态方法

游离快静态块

类部类静态类部类

//外部类，不能使用static修饰
public class Static_ {

	// a，b都称为属性，成员变量
	private int a;// 非静态属性（非静态变量，实例变量）
	private static int b;// 静态属性（静态变量，类变量）

	// 局部变量只能使用final修饰，下面的方法fun中c报错，static不可以修饰局部变量
//	public void fun() {
//		static int c;
//	}

	public void fun2() {// 非静态方法（实例方法）

	}

	public static void fun1() {// 静态方法（类方法）

	}

	static {// 可以修饰游离块
		System.out.println("静态块");
	}

	public class Cat {// 非静态类部类

	}

	public static class Dog {// 静态类部类

	}

}

静态成员变量和非静态成员变量的区别

在这里插入图片描述

package com.java;

public class Student {
	//名字
	private String name;
	//年龄
	private static int age = 18;
	
	
	public Student(String name) {
		super();
		this.name = name;
	}


	public String getName() {
		return name;
	}


	public void setName(String name) {
		this.name = name;
	}


	public static int getAge() {
		return age;
	}


	public static void setAge(int age) {
		Student.age = age;
	}


	//static修饰的成员变量不可自动生成
	@Override
	public String toString() {
		return "Student中的name [name=" + name + "]";
	}
	
	
	public static void main(String[] args) {
		Student s = new Student("周三");
		System.out.println(s.toString());
		//修改s的名字
		s.setName("王五");
		System.out.println(s.toString());
		//静态属性只能通过特定的方法访问，set，get方法
		s.setAge(20);
		System.out.println("age="+getAge());
	}
	

}

package com.java;

public class Demo {
	
	private static int a = 10;
	private int b = 20;
	
	public static void main(String[] args) {
		//静态方法中，只能"直接"访问静态的方法和属性
		System.out.println(a);
		
		//非静态方法需要创建对象才能调用
		Demo d = new Demo();
		System.out.println(d.b);
	}

}

静态方法和非静态方法的区别

区别1：

static修饰的方法，静态方法（类方法）

没有使用static修饰的方法，非静态方法（实例方法)

区别2：

非静态方法必须先创建对象才能访问

静态方法只能直接访问静态的成分

在方法中可以间接访问静态方法

new 对象都可以调用，但是不建议用对象名访问

静态方法中不能使用this关键字和super关键字

static块，使用static的匿名块（游离快）

静态块属于类，在类加载的时候首先执行且只执行一次。

package com.java;

class Father{
	static {
		System.out.println("Father中的静态块");
		
	}
	
	{
		System.out.println("Father中的游离快");
		
	}
	
	public Father() {
		System.out.println("Father中的无参构造器");
	}
}

class Son extends Father{
	static {
		System.out.println("Son中的静态块");
		
	}
	{
		System.out.println("Son中的游离块");
		
	}
	public Son() {
		System.out.println("Son中的无参构造器");
	}
}
public class Demo1 {

	public static void main(String[] args) {
//		什么时候叫类的加载？
		//使用某一个类，jvm就会加载那个类
		Son s = new Son();
        //只要创建对象了，静态块都只执行一次
		System.out.println("==================");
		Father f = new Father();
	}
}

在这里插入图片描述

设计模式

模式：在某些场景下，针对某类问题的某种通用的解决方案。

设计模式（Design pattren)是一种反复使用，多数人知晓的、经过分类编目的、代码设计经验的总结，使用设计模式是为了可重用代码，让代码更容易被他人理解，保证代码的可靠性。

（Singleton单例）模式

单例模式是指“确保某一类只有一个实例，而且自行实例化并向整个系统提供这个实例。

单列模式分为懒汉式和饿汉式：
在这里插入图片描述

简介

王者荣耀五个英雄攻击敌方水晶，当水晶血条小于0，游戏结束

懒汉式

package com.java;

//一个类有且只有一个实例
public class Shuijing {
	// 1、构造器私有化
	private Shuijing() {

	}

	// 2、类定义中含有一个该类的静态私有对象
	private static Shuijing getName;

	// 3、该类提供一个静态的公有的方法
	// 用于创建获取它本身的静态私有对象
	public static Shuijing getInstence() {
		if (getName == null) {
			getName = new Shuijing();
		}
		return sj;
	}

}

package com.java;

public class Test {

	public static void main(String[] args) {
		//因为构造方法私有，无法访问
		//Shuijing sj = new Shuijing();
		Shuijing s1 = Shuijing.getInstence();
		Shuijing s2 = Shuijing.getInstence();
		System.out.println(s1==s2);//true
	}
}

饿汉式

package com.java;

//一个类有且只有一个实例
public class SJ {
	// 1、构造器私有化
	private SJ() {

	}

	// 2、类定义中含有一个该类的静态私有对象
	private static final SJ sj = new SJ();

	// 3、该类提供一个静态的公有的方法
	// 用于创建获取它本身的静态私有对象
	public static SJ getInstence() {
		return sj;
	}

}

登记式单例

内部类只有在外部类被调用才加载，产生SINGLETON实例：又不用锁。此模式有上述两个模式的优点，屏蔽了它们的缺点，是最好的单例模式。

package com.java;

public class GrilFriend {

	//构造方法私有化
	private GrilFriend() {

	}

	//提供一个public static修饰的方法，用于返回GrilFriend对象
	public static GrilFriend getInstance() {
		return Inner.girl;
	}

	//定义一个私有的静态类部类
	private static class Inner {
		//私有静态常量gril
		private static final GrilFriend girl = new GrilFriend();
	}
	
	//弥补：饿汉模式，内存浪费
	//弥补：懒汉模式，在多线程的环境下，创建多个对象

}

final（最终的，不可变）

功能：标记所有通用的功能不能随意更改。

可以用在属性、类、方法上。

final不能被继承

final成员变量只允许赋值一次，可以通过构造方法里赋值。

final局部变量即为常量，只能赋值一次。

final方法不允许被子类覆盖

final一般用于标记那些通用性的功能不能随意修改。

继承提高了代码的复用性，并方便开发

在类不想要子类，或者有些类的方法不想被其他类改写的时候，用final关键字就可以解决这些问题

package com.java;

public class Demo3 {
	
	public static void main(String[] args) {
		F s = new S();
		s.m1();
		s.m2();
		
		S s1 = new S();
		s1.m1();
		s1.m2();
	}
	
}

class F{
	
	public final void m1() {
		System.out.println("F-----m1");
	}
	
	public void m2() {
		System.out.println("F-----m2");
	}
}

class S extends F{
	
	//重写F中final修饰的m1报错
//	public final void m1() {
//		System.out.println("F-----m1");
//	}
	
	public void s1() {
		System.out.println("S-----s1");
	}
}

abstract(抽象类)

在这里插入图片描述

使用abstract修饰的类，称为抽象类

特点：不能创建对象，下图创建对象Animal编译错误

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-RalANWfs-1594890897488)(C:\Users\lx\AppData\Local\Temp\1594887736932.png)]

package com.java;

public abstract class Animal {
	
	public Animal() {
		System.out.println("Animal无参构造方法");
	}
	

	//抽象方法必须定义在抽象类中
	public abstract void m1();//没有方法体的方法
	//什么时候把类定义为抽象类
	//情况1：有抽象方法（使用abstract修饰，只有方法的声明，没有方法体）
    //一个子类继承抽象类，但是没有把父类的所有抽象方法都继承，子类就需要定义成抽象类，不然就只能继承全部Animal抽象类方法，继承了所有抽象类方法，子类也可以定义为抽象的
    
    //接口（比抽象类更抽象类）
    // 实现类实现某个或者多个接口，必须把所有接口中的抽象方法都实现，否则实现类也应该定义为抽象的
	
	public abstract void m2();
	public abstract void m3();
	public abstract void m4();
	public abstract void m5();
	/*
	 * public static void main(String[] args) {
	 * 
	 * Animal al = new Animal();//抽象类不能创建对象 }
	 */
}

package com.java;

public abstract class Dog extends Animal{

	@Override
	public void m1() {
		
		System.out.println("吃东西");
	}

	@Override
	public void m2() {
		System.out.println("玩耍");
	}
}

设计一个能细分为矩形、三角形、圆形和椭圆形的“图形”类。使用继承将这些图形分类，找出能作为基类部分的共同特征(如校准点)和方法(如画法、初始化)，并看看这些图形是否能进一步划分为子类。本题只考虑实现思想，不考虑具体实现的细节，实现方式可自由发挥。

public abstract class Shapes {

	//得出周长
	public abstract double perimeter();
	//得出面积
	public abstract double area();
	//得出形状
	public abstract String getType();
	
}

public class Triangle extends Shapes{
	//定义三角形的属性
	private double a;
	private double b;
	private double c;
	

	public Triangle(double a, double b, double c) {
		super();
		this.a = a;
		this.b = b;
		this.c = c;
	}

	@Override
	public double perimeter() {
		return a+b+c;
	}

	@Override
	public double area() {
		double p = (a+b+c)/2;
		return Math.sqrt(p*(p-a)*(p-b)*(p-c));
	}

	@Override
	public String getType() {
		
		return "三角形";
	}

}

public class Yuan extends Shapes{
	
	private double r;
	
	public Yuan(double r) {
		super();
		this.r = r;
	}

	@Override
	public double perimeter() {
		
		return 2*Math.PI*r;
	}

	@Override
	public double area() {
		
		return Math.PI*r*r;
	}

	@Override
	public String getType() {
		
		return "圆形";
	}

public class TestShapes {
	public static void main(String[] args) {
		
		Triangle t = new Triangle(2,4,3);
		double d = t.perimeter();
		double d1 = t.area();
		t.getType();
		System.out.println(t.getType()+"面积"+d1+"周长"+d);
	}

}