HelloWorld
登录

Java高级特性2

Wesley13

2021-10-11

1293 0 0

[TOC]

1. static关键字

1.1 类变量、类方法

1	/**
2	 * static关键字
3	 * 类变量不用实例化，直接类名.属性名就可以使用，是类的一部分，被所有这个类的实例化所共享，也可以叫做静态变量
4	 * 如果想让一个类的所有实例共享数据，就用类变量!
5	 * 
6	 * 实列变量，只是实例化后才能使用，属于实例化对象的一部分，不能公用
7	 * 
8	 * 使用范围
9	 * 可用static修饰属性、方法、代码块、内部类
10	 * 被修饰后的成员具备以下特点
11	 * 1.随着类的加载而加载(类加载后，静态方法或属性就可以使用了，类名.方法名)
12	 * 2.优先于对象存在，不用new就可以使用
13	 * 3.修饰的成员被所有对象所共享
14	 * 4.访问权限允许时，可不创建对象，直接被类调用
15	 * 
16	 * 注意:
17	 * 类变量，这种可以被所有实例化对象所共享的属性，使用起来要慎重，因为只要一改，所有类都能得到变化
18	 * 
19	 * 类方法：作为工具类的情况较多
20	 * static方法内部不能有this(也不能有super)，因为this是针对对象的，static是类的，重载方法的方法需要同时为static或非static
21
22	 */

1.2 工具类

静态方法

1//判断字符串是否为空或null
2public class Utils {
3	public static boolean isEmpty(String s) {
4		boolean flag = false;
5		if (s ==null && s.equals("")){
6			flag = true;
7		}
8		return flag;
9	}
10	
11}
12
13//调用工具类
14Utils.isEmpty("test")

1.3 单例 (Singleton)设计模式

懒汉式单例设计模式

1public class Single1 {
2	private Single1() {}
3	/**
4	 * 懒汉式实例:第一次创建实例前为null,第一次创建实例后，创建，后面的都是同一个实例
5	 */
6	//私有的类变量，为null;
7	private static Single1 s1 = null;
8	
9	//公共的方法，如果s1为null,就创建实例，后面的就不用创建了
10	public static Single1 getInstance() {
11		if(s1 == null) {
12			s1 = new Single1();
13		}
14		return s1;
15	}
16}
17

饿汉式单例设计模式

1public class Single {
2	/**
3	 * 单例设计模式:
4	 * 设计模式:就是在我们实际编程过程中，逐渐总结出的一些解决问题的套路
5	 * 单例设计模式：只有一个实例(实例化对象)在整个软件系统运行过程中，这个类只被实例化一次，以后无论在哪都只调用这一个实例
6	 */
7
8	//饿汉式
9	//私有的构造方法
10	private Single() {
11		
12	}
13	//私有的类变量，创建实例
14	private static Single s = new Single();
15	
16	//公共的方法，返回私有的类变量 
17	public static Single getInstance() {
18		return s;
19	}
20}

懒汉式和饿汉式的区别

1		/**
2		 * 懒汉式和饿汉式的区别:
3		 * 就是什么时候new这个对象，懒汉式，是在第一次有人调用getlnstance方法时类new对象，
4		 * 以后再有人调用getinstance方法直接就返回第一次new好的对象
5		 * 
6		 * 饿汉式，是在类加载之后，还没有人调用的时候，就new好一个对象，以后无论谁来调用
7		 * getinstance方法都直接返回直接new好的那个对象
8		 */

1.4 main方法

1		/**
2		 * main方法
3		 * public static void main(String[] args) {}
4		 * 由于java虚拟机需要调用类的main()方法，所以该方法的访问权限必须是public，
5		 * 又因为java虚拟机在执行main()方法时不必创建对象，所以该方法必须是static的，
6		 * 该方法接收一个String类型的数组参数，
7		 * 该数组中保存执行java命令时传递给所运行的类的参数
8		 */

2. 类的成员之初始化块

2.1 非静态代码块

1//非静态代码块
2	{
3		System.out.println("这是非静态代码块中的方法1");
4	}
5	{
6		System.out.println("这是非静态代码块中的方法2");
7	}
8

2.2静态代码块

1	//静态代码块
2	//复杂的属性，实例属性
3		static TestPer tp= new TestPer();
4	static {
5		//这里只能使用静态的属性和方法
6		age = 2;
7		showAge();
8		/**
9		 * 这程序的运行过程中，非静态代码块每次new对象都有重新执行
10		 * 静态代码块只执行一次
11		 */
12		System.out.println("这执行的是静态代码块");
13		//复杂的属性，可以通过代码块来初始化调用
14		tp.age = 1;
15		tp.name = "张三";
16	}

2.3 匿名内部类

1		//匿名内部类
2		Person p = new Person() {//这就是一个Person的匿名子类,
3			/**
4			 * 构建了一个没有类名的Person的子类，也就是匿名的Person子类
5			 * 这两种类没有类名，就不能显示的new的方法创建对象，如果要是还要在构造器中初始化
6			 * 属性就没有办法了，这样情况就要用代码块{}来初始化工作
7			 */
8			{
9				//
10				super.name = "李四";
11			}
12			//从写方法
13			@Override
14			public void test() {
15				System.out.println("=========");
16			}
17		};//分号结尾
18		System.out.println(p.name);
19		p.test();

2.4 总结

  1. 初始化块(代码块)作用：对Java对象进行初始化
  2. 程序的执行顺序：声明成员变量的默认值-显式初始化-多个初始化块依次被执行（同级别下按先后顺序执行）-构造器再对成员进行赋值操作
  3. 一个类中初始化块若有修饰符，则只能被static修饰，称为静态代码块(static block )，当类被载入时，类属性的声明和静态代码块先后顺序被执行，且只被执行一次。
  4. 非静态代码块：没有static修饰的代码块 - 可以有输出语句。 - 可以对类的属性声明进行初始化操作。 - 可以调用静态和非静态的变量或方法。 - 若有多个非静态的代码块，那么按照从上到下的顺序依 次执行。 - 每次创建对象的时候，都会执行一次。且先于构造器执行
  5. 静态代码块：用static 修饰的代码块 - 可以有输出语句。 - 可以对类的属性声明进行初始化操作。 - 不可以对非静态的属性初始化。即：不可以调用非静态的属 性和方法。 - 若有多个静态的代码块，那么按照从上到下的顺序依次执行。 - 静态代码块的执行要先于非静态代码块。 - 静态代码块只执行一次

3. final关键字

在Java中声明类、属性和方法时，可使用关键字final来修饰,表示“最终”。 final标记的类不能被继承。提高安全性，提高程序的可读性 final标记的方法不能被子类重写 final标记的变量(成员变量或局部变量)即称为常量。名称大写，且只能被赋值一次。 static final：全局常量

4. 抽象类

1/**
2 * 抽象类:
3 * 1.用abstract关键字来修饰一个类时，这个类叫做抽象类
4 * 2.用abstract来修饰一个方法时，该方法叫做抽象方法
5 * 3.抽象方法：只有方法的声明，没有方法的实现。以分号结束：abstract int abstractMethod( int a );
6 * 4.含有抽象方法的类必须被声明为抽象类
7 * 5.抽象类不能被实例化。抽象类是用来作为父类被继承的，抽象类的子类必须重写父类的抽象方法，并提供方法体。若没有重写全部的抽象方法，仍为抽象类
8 * 6.不能用abstract修饰属性、私有方法、构造器、静态方法、final的方法
9 * @author Zw
10 *
11 */
12public abstract class Employee {
13	String id;
14	String name;
15	double salary;
16	//构造方法
17	public Employee() {}
18	//抽象方法
19	public abstract void work();
20}
21
22/**
23 * 公司员工类，继承Employee类
24 * 获取和设置员工信息
25 *
26 * @author Zw
27 *
28 */
29class CommonEmployee extends Employee{
30	@Override
31	public void work() {
32		System.out.println("这是一个员工.");
33	}
34	public void setEmployeeInfo(String id, String name, double salary) {
35		super.id = id;
36		super.name = name;
37		super.salary = salary;
38	}
39	public void getEmployeeInfo() {
40		System.out.println(id+"\n"+name+"\n"+salary);
41	}
42
43}
44
45/**
46 * 领导类继承Employee
47 * @author Zw
48 *
49 */
50class Manager extends Employee{
51	double bonus;
52	@Override
53	public void work() {
54		System.out.println("这是一个领导.");		
55	}
56	public void setManager(String id, String name, double salary, double bonus) {
57		super.id = id;
58		super.name = name;
59		super.salary = salary;
60		this.bonus = bonus;//子类的属性用this
61	}
62	public void getManager() {
63		System.out.println(id+"\n"+name+"\n"+salary+"\n"+bonus);
64	}
65
66}

5. 模板模式的设计

1/**
2 * 模板模式的设计:
3 * 抽象类体现的就是一种模板模式的设计，抽象类作为多个子类的通用模板，子类在抽象类的基础上进行扩展、改造，但子类总体上会保留抽象类的行为方式。
4 * 解决的问题：
5 * 1. 当功能内部一部分实现是确定，一部分实现是不确定的。这时可以把不确定的部分暴露出去，让子类去实现。
6 * 2. 编写一个抽象父类，父类提供了多个子类的通用方法，并把一个或多个方法留给其子类实现，就是一种模板模式。
7
8 * @author Zw
9 *
10 */
11public abstract class Template {
12	public abstract void run();
13	//提供子类调用的，计算run方法运行时间
14	public final void runTime() {
15		long start = System.currentTimeMillis();
16		run();
17		long end = System.currentTimeMillis();
18		System.out.println(end - start);
19	}
20}
21
22class testTemplate extends Template{
23	@Override
24	public void run() {
25		int a = 1;
26		for(int i=0; i<9999999;i++) {
27			a += i;
28		}		
29		
30	}
31}
32
33//模板设计模式,main中调用
34		Template tp = new testTemplate();
35		tp.runTime();//7毫秒

6. 接口

6.1 什么时候使用接口

  • 抽象类是对于一类事物的高度抽象，其中既有属性也有方法；

  • 接口是对方法的抽象，也就是一系列动作的抽象

  • 当需要对一类事物抽象的时候，应该使用抽象类，好形成一个法类

  • 当需要对一系列的动作(方法)抽象，就使用接口，需要使用这些动作的类去实现相应的接口

6.2 接口的特点

  • 用interface来定义。

  • 接口中的所有成员变量都默认是由public static final修饰的。

  • 接口中的所有方法都默认是由public abstract修饰的。

  • 接口没有构造器。

  • 接口采用多层继承机制。

  • 实现接口的类中必须提供接口中所有方法的具体实现内容，方可实例化。否则，仍为抽象类

  • 接口的主要用途就是被实现类实现

  • 与继承关系类似，接口与实现类之间存在多态性

  • 定义Java类的语法格式：先写extends，后写implements

  • 如果实现接口的类中没有实现接口中的全部方法，必须将此类定义为抽象类

6.3 具体实例

需求: teach类继承person类，并实现cook、sing接口

代码

1 * @author Zw
2 * person 父类
3 */
4public class Person1 {
5	String name;
6	int age;
7	int sex;
8	public void showInfo() {
9		
10	}
11	
12}
13
14/**
15 * Cook接口
16 * @author Zw
17 */
18public interface Cook {
19	void cooking();
20}
21
22/**
23 * Sing接口
24 * @author Zw
25 */
26public interface Sing {
27	void singing();
28}
29
30
31public class TeachCT extends Person1 implements Cook,Sing {//先继承后实现
32
33	String score;//老师自己的属性，科目
34	
35	@Override
36	public void showInfo() {
37		System.out.println("这是一个会唱歌做菜的老师的信息");
38		System.out.println(super.name+"\n"+super.age+"\n"+super.sex+"\n"+this.score);
39	}
40	public void setInfo() {
41		super.name = "李四";
42		super.age = 11;
43		super.sex = 1;
44		this.score = "物理";
45	}
46
47	@Override
48	public void singing() {//重写singing
49		System.out.println(super.name+"老师擅长美声唱法!");
50		
51	}
52	@Override
53	public void cooking() {//重写cooking
54		System.out.println(super.name+"老师擅长炒菜!");
55		
56	}
57}
58
59
60//调用
61//接口
62		TeachCT  tc = new TeachCT();
63		tc.setInfo();
64		tc.showInfo();
65		tc.cooking();
66		tc.singing();
67		
68		//接口对象的多态
69		Cook tp1 = new TeachCT();//可以转为实现接口的类型
70		tp1.cooking();//只能使用Cook类自己的属性和方法

7. 工厂模式

FactoryMethod模式是设计模式中应用最为广泛的模式，在面向对象的编程中，对象的创建工作非常简单，对象的创建时机却很重要。FactoryMethod解决的就是这个问题，它通过面向对象的手法，将所要创建的具体对象的创建工作延迟到了子类，从而提供了一种扩展的策略，较好的解决了这种紧耦合的关系。 实例

1//父类接口
2public interface BMW {
3	//产品信息
4	void showInfo();
5}
6
7//宝马3系产品，实现接口
8class BMW1 implements BMW{
9
10	@Override
11	public void showInfo() {
12		System.out.println("这是BMW3系产品");		
13	}	
14} 
15
16//宝马5系产品
17class BMW5 implements BMW{
18
19	@Override
20	public void showInfo() {
21		System.out.println("这是BMW5系产品");		
22	}	
23} 
24
25//宝马7系产品
26class BMW7 implements BMW{
27
28	@Override
29	public void showInfo() {
30		System.out.println("这是BMW7系产品");		
31	}	
32} 
33
34
35//工厂模式
36/**
37 * 汽车生产工厂接口
38 * 通过工厂把new对象给隔离，通过产品的接口可以接受不同实际产品的实现类，
39 * 实现类名改变不影响其他合作开发人员的编程
40 * @author Zw
41 *
42 */
43public interface BMWFactory {
44	BMW productBMW();
45}
46/**
47 * 实现具体车型的生产工厂
48 * @author Zw
49 *
50 */
51
52class BMW3Factory implements BMWFactory{
53
54	@Override
55	public BMW productBMW() {
56		System.out.println("这是生产宝马3系车");
57		return new BMW1();//return 具体的产品
58	}	
59}
60
61class BMW5Factory implements BMWFactory{
62
63	@Override
64	public BMW productBMW() {
65		System.out.println("这是生产宝马3系车");
66		return new BMW5();
67	}	
68}
69
70class BMW7Factory implements BMWFactory{
71
72	@Override
73	public BMW productBMW() {
74		System.out.println("这是生产宝马3系车");
75		return new BMW7();
76	}	
77}
78
79//调用
80public class Test2 {
81	public static void main(String[] args) {
82		/**
83		 * 调用工厂方法
84		 */
85		BMW b3 = new BMW3Factory().productBMW();//new 具体车型的产品().方法()
86		b3.showInfo();
87		
88		BMW b5 = new BMW5Factory().productBMW();
89		b5.showInfo();
90		
91		BMW b7 = new BMW7Factory().productBMW();
92		b7.showInfo();
93	}
94}
点赞
收藏

评论区

加载中...

相关推荐

手写Java HashMap源码

HashMap的使用教程HashMap的使用教程HashMap的使用教程HashMap的使用教程HashMap的使用教程22

java中static关键字的使用

知识点：java中，static关键字修饰类的变量、方法、代码块、内部类场景：我们在创建类的方法和变量时，如果这个类在创建多个对象时，共用同一个属性或者方法，就可以使用static关键字修饰，因为static修饰的变量，在内存的静态域存在的值，被类的多个实例所共用，实际上我们在编写一个类时，就是在描述对象的属性和行为，并没有产生实质上的对

java中static的作用详解

java中static关键字表示静态的意思，主要用于以下三点，static成员变量，static成员方法和static块。在类中如果定义了static类型的对象（变量或者方法），在java虚拟机（JVM）加载类时，该对象就会被实例化，在使用的时候就不需要再去实例化，直接调用就可以了。常与private，public搭配使用。下面详细说一下这三部分。1

java中一些常考知识

一、static的作用　static是修饰符，用于修饰成员变量（静态变量/类变量）。static修饰的成员被所有对象共享。static优先于对象存在。static修饰的成员可以用类名.静态成员来访问。注：1.静态方法只能访问静态成员，非静态方法既能访问静态成员又可以访问非静态成员。2.静态方法中不可

java成员变量的初始化

类变量(static变量,不需要实例化对象也可以引用)实例变量(非static变量,需要实例化对象)局部变量(类的成员函数中的变量)初始化方式:构造函数初始化变量声明时初始化代码块初始化java自动初始化(在构造函数执行之前执行) java保证所有变量被使用之前都是经过初始化的(声明并且定义过,被赋值

java中的类与对象（1）

    首先理解一下类和对象的关系，可以说：类是对象的抽象，对象是类的实例。类一个类中，通常上包含了属性和功能。属性通常用变量表达，功能通常上用函数表达。编写一个类class类名｛//属性，用变量表达//功能，用函数表达｝对象实例化对象的方法及含义：类名 对象名 new 

Java高级特性2 - HelloWorld